Interface SubscriberBlackboxVerificationRules

All Known Implementing Classes:
FlowSubscriberBlackboxVerification, SubscriberBlackboxVerification
public interface SubscriberBlackboxVerificationRules
Internal TCK use only. Add / Remove tests for SubscriberBlackboxVerification here to make sure that they arre added/removed in the other places.

  • Method Details

    • required_spec201_blackbox_mustSignalDemandViaSubscriptionRequest

      void required_spec201_blackbox_mustSignalDemandViaSubscriptionRequest() throws Throwable
      Asks for a Subscriber instance, expects it to call request() in a timely manner and signals as many onNext items as the very first request amount specified by the Subscriber.

      Verifies rule: 2.1

      Notes:

      • This test emits the number of items requested thus the Subscriber implementation should not request too much.
      • Only the very first request amount is considered.
      • This test doesn't signal onComplete after the first set of onNext signals has been emitted and may cause resource leak in Subscribers that expect a finite Publisher.
      • The test ignores cancellation from the Subscriber and emits the requested amount regardless.

      If this test fails, the following could be checked within the Subscriber implementation:

      • if the Subscriber requires external stimulus to begin requesting; override the SubscriberBlackboxVerification.triggerRequest(org.reactivestreams.Subscriber) method in this case,
      • the TestEnvironment has large enough timeout specified in case the Subscriber has some time-delay behavior,
      • if the Subscriber requests zero or a negative value in some circumstances,
      • if the Subscriber throws an unchecked exception from its onSubscribe or onNext methods.
      Throws:
      Throwable

    • untested_spec202_blackbox_shouldAsynchronouslyDispatch

      void untested_spec202_blackbox_shouldAsynchronouslyDispatch() throws Exception
      Currently, this test is skipped because there is no agreed upon approach how to detect if the Subscriber really goes async or just responds in a timely manner.

      Verifies rule: 2.2

      Throws:
      Exception

    • required_spec203_blackbox_mustNotCallMethodsOnSubscriptionOrPublisherInOnComplete

      void required_spec203_blackbox_mustNotCallMethodsOnSubscriptionOrPublisherInOnComplete() throws Throwable
      Asks for a Subscriber, signals an onSubscribe followed by an onComplete synchronously, and checks if neither request nor cancel was called from within the Subscriber's onComplete implementation.

      Verifies rule: 2.3

      Notes:

      • The test checks for the presensce of method named "onComplete" in the current stacktrace when handling the request or cancel calls in the test's own Subscription.

      If this test fails, the following could be checked within the Subscriber implementation:

      • no calls happen to request or cancel in response to an onComplete directly or indirectly,
      • if the Subscriber throws an unchecked exception from its onSubscribe or onComplete methods.
      Throws:
      Throwable

    • required_spec203_blackbox_mustNotCallMethodsOnSubscriptionOrPublisherInOnError

      void required_spec203_blackbox_mustNotCallMethodsOnSubscriptionOrPublisherInOnError() throws Throwable
      Asks for a Subscriber, signals an onSubscribe followed by an onError synchronously, and checks if neither request nor cancel was called from within the Subscriber's onComplete implementation.

      Verifies rule: 2.3

      Notes:

      • The test checks for the presensce of method named "onError" in the current stacktrace when handling the request or cancel calls in the test's own Subscription.

      If this test fails, the following could be checked within the Subscriber implementation:

      • no calls happen to request or cancel in response to an onError directly or indirectly,
      • if the Subscriber throws an unchecked exception from its onSubscribe or onError methods.
      Throws:
      Throwable

    • untested_spec204_blackbox_mustConsiderTheSubscriptionAsCancelledInAfterRecievingOnCompleteOrOnError

      void untested_spec204_blackbox_mustConsiderTheSubscriptionAsCancelledInAfterRecievingOnCompleteOrOnError() throws Exception
      Currently, this test is skipped because there is no way to check what the Subscriber "considers" since rule §2.3 forbids interaction from within the onError and onComplete methods.

      Verifies rule: 2.4

      Notes:

      • It would be possible to check if there was an async interaction with the test's Subscription within a grace period but such check is still not generally decisive.
      Throws:
      Exception

    • required_spec205_blackbox_mustCallSubscriptionCancelIfItAlreadyHasAnSubscriptionAndReceivesAnotherOnSubscribeSignal

      void required_spec205_blackbox_mustCallSubscriptionCancelIfItAlreadyHasAnSubscriptionAndReceivesAnotherOnSubscribeSignal() throws Exception
      Asks for a Subscriber, signals onSubscribe twice synchronously and expects the second Subscription gets cancelled in a timely manner and without any calls to its request method.

      Verifies rule: 2.5

      Notes:

      • The test doesn't signal any other events than onSubscribe and may cause resource leak in Subscribers that expect a finite Publisher.

      If this test fails, the following could be checked within the Subscriber implementation:

      • if the Subscribe.onSubscribe implementation actually tries to detect multiple calls to it,
      • if the second Subscription is cancelled asynchronously and that takes longer time than the TestEnvironment's timeout permits.
      Throws:
      Exception

    • untested_spec206_blackbox_mustCallSubscriptionCancelIfItIsNoLongerValid

      void untested_spec206_blackbox_mustCallSubscriptionCancelIfItIsNoLongerValid() throws Exception
      Currently, this test is skipped because it requires more control over the Subscriber implementation to make it cancel the Subscription for some external condition.

      Verifies rule: 2.6

      Throws:
      Exception

    • untested_spec207_blackbox_mustEnsureAllCallsOnItsSubscriptionTakePlaceFromTheSameThreadOrTakeCareOfSynchronization

      void untested_spec207_blackbox_mustEnsureAllCallsOnItsSubscriptionTakePlaceFromTheSameThreadOrTakeCareOfSynchronization() throws Exception
      Currently, this test is skipped because it requires more control over the Subscriber implementation to issue requests based on external stimulus.

      Verifies rule: 2.7

      Throws:
      Exception

    • untested_spec208_blackbox_mustBePreparedToReceiveOnNextSignalsAfterHavingCalledSubscriptionCancel

      void untested_spec208_blackbox_mustBePreparedToReceiveOnNextSignalsAfterHavingCalledSubscriptionCancel() throws Throwable
      Currently, this test is skipped because there is no way to make the Subscriber implementation cancel the test's Subscription and check the outcome of sending onNexts after such cancel.

      Verifies rule: 2.8

      Throws:
      Throwable

    • required_spec209_blackbox_mustBePreparedToReceiveAnOnCompleteSignalWithPrecedingRequestCall

      void required_spec209_blackbox_mustBePreparedToReceiveAnOnCompleteSignalWithPrecedingRequestCall() throws Throwable
      Asks for a Subscriber, expects it to request some amount and in turn be able to receive an onComplete synchronously from the request call without any onNext signals before that.

      Verifies rule: 2.9

      Notes:

      • The test ignores cancellation from the Subscriber.
      • Invalid request amounts are ignored by this test.
      • Concurrent calls to the test's Subscription.request() must be externally synchronized, otherwise such case results probabilistically in multiple onComplete calls by the test.

      If this test fails, the following could be checked within the Subscriber implementation:

      Throws:
      Throwable

    • required_spec209_blackbox_mustBePreparedToReceiveAnOnCompleteSignalWithoutPrecedingRequestCall

      void required_spec209_blackbox_mustBePreparedToReceiveAnOnCompleteSignalWithoutPrecedingRequestCall() throws Throwable
      Asks for a Subscriber and expects it to handle onComplete independent of whether the Subscriber requests items or not.

      Verifies rule: 2.9

      Notes:

      • Currently, the test doesn't call onSubscribe on the Subscriber which violates §1.9.

      If this test fails, the following could be checked within the Subscriber implementation:

      • if the Subscriber throws an unchecked exception from its onSubscribe or onComplete methods.
      Throws:
      Throwable

    • required_spec210_blackbox_mustBePreparedToReceiveAnOnErrorSignalWithPrecedingRequestCall

      void required_spec210_blackbox_mustBePreparedToReceiveAnOnErrorSignalWithPrecedingRequestCall() throws Throwable
      Asks for a Subscriber, signals onSubscribe followed by an onError synchronously.

      Verifies rule: 2.10

      Notes:

      • Despite the method name, the test doesn't expect a request signal from Subscriber and emits the onError signal anyway.

      If this test fails, the following could be checked within the Subscriber implementation:

      • if the Subscriber throws an unchecked exception from its onSubscribe or onError methods.
      Throws:
      Throwable

    • required_spec210_blackbox_mustBePreparedToReceiveAnOnErrorSignalWithoutPrecedingRequestCall

      void required_spec210_blackbox_mustBePreparedToReceiveAnOnErrorSignalWithoutPrecedingRequestCall() throws Throwable
      Asks for a Subscriber, signals onSubscribe followed by an onError synchronously.

      Verifies rule: 2.10

      If this test fails, the following could be checked within the Subscriber implementation:

      • if the Subscriber throws an unchecked exception from its onSubscribe or onError methods.
      Throws:
      Throwable

    • untested_spec211_blackbox_mustMakeSureThatAllCallsOnItsMethodsHappenBeforeTheProcessingOfTheRespectiveEvents

      void untested_spec211_blackbox_mustMakeSureThatAllCallsOnItsMethodsHappenBeforeTheProcessingOfTheRespectiveEvents() throws Exception
      Currently, this test is skipped because it would require analyzing what the Subscriber implementation does.

      Verifies rule: 2.11

      Throws:
      Exception

    • untested_spec212_blackbox_mustNotCallOnSubscribeMoreThanOnceBasedOnObjectEquality

      void untested_spec212_blackbox_mustNotCallOnSubscribeMoreThanOnceBasedOnObjectEquality() throws Throwable
      Currently, this test is skipped because the test for §2.5 is in a better position to test for handling the reuse of the same Subscriber.

      Verifies rule: 2.12

      Notes:

      • In addition to §2.5, this rule could be better verified when testing a Publisher's subscription behavior.
      Throws:
      Throwable

    • untested_spec213_blackbox_failingOnSignalInvocation

      void untested_spec213_blackbox_failingOnSignalInvocation() throws Exception
      Currently, this test is skipped because it would require more control over the Subscriber to fail internally in response to a set of legal event emissions, not throw any exception from the Subscriber methods and have it cancel the Subscription.

      Verifies rule: 2.13

      Throws:
      Exception

    • required_spec213_blackbox_onSubscribe_mustThrowNullPointerExceptionWhenParametersAreNull

      void required_spec213_blackbox_onSubscribe_mustThrowNullPointerExceptionWhenParametersAreNull() throws Throwable
      Asks for a Subscriber and signals an onSubscribe event with null as a parameter and expects an immediate NullPointerException to be thrown by the Subscriber.onSubscribe method.

      Verifies rule: 2.13

      If this test fails, the following could be checked within the Subscriber implementation:

      • if the Subscriber throws a NullPointerException from its onSubscribe method in response to a null parameter and not some other unchecked exception or no exception at all.
      Throws:
      Throwable

    • required_spec213_blackbox_onNext_mustThrowNullPointerExceptionWhenParametersAreNull

      void required_spec213_blackbox_onNext_mustThrowNullPointerExceptionWhenParametersAreNull() throws Throwable
      Asks for a Subscriber, signals an onSubscribe event followed by a onNext with null as a parameter and expects an immediate NullPointerException to be thrown by the Subscriber.onNext method.

      Verifies rule: 2.13

      Notes:

      • The test ignores cancellation and requests from the Subscriber and emits the onNext signal with a null parameter anyway.

      If this test fails, the following could be checked within the Subscriber implementation:

      • if the Subscriber throws a NullPointerException from its onNext method in response to a null parameter and not some other unchecked exception or no exception at all.
      Throws:
      Throwable

    • required_spec213_blackbox_onError_mustThrowNullPointerExceptionWhenParametersAreNull

      void required_spec213_blackbox_onError_mustThrowNullPointerExceptionWhenParametersAreNull() throws Throwable
      Asks for a Subscriber, signals an onSubscribe event followed by a onError with null as a parameter and expects an immediate NullPointerException to be thrown by the Subscriber.onError method.

      Verifies rule: 2.13

      Notes:

      • The test ignores cancellation from the Subscriber and emits the onError signal with a null parameter anyway.

      If this test fails, the following could be checked within the Subscriber implementation:

      • if the Subscriber throws a NullPointerException from its onNext method in response to a null parameter and not some other unchecked exception or no exception at all.
      Throws:
      Throwable

    • untested_spec301_blackbox_mustNotBeCalledOutsideSubscriberContext

      void untested_spec301_blackbox_mustNotBeCalledOutsideSubscriberContext() throws Exception
      Currently, this test is skipped because there is no agreed upon way for specifying, enforcing and testing a Subscriber with an arbitrary context.

      Verifies rule: 3.1

      Throws:
      Exception

    • untested_spec308_blackbox_requestMustRegisterGivenNumberElementsToBeProduced

      void untested_spec308_blackbox_requestMustRegisterGivenNumberElementsToBeProduced() throws Throwable
      Currently, this test is skipped because element production is the responsibility of the Publisher and a Subscription is not expected to be the active element in an established subscription.

      Verifies rule: 3.8

      Throws:
      Throwable

    • untested_spec310_blackbox_requestMaySynchronouslyCallOnNextOnSubscriber

      void untested_spec310_blackbox_requestMaySynchronouslyCallOnNextOnSubscriber() throws Exception
      Currently, this test is skipped because element production is the responsibility of the Publisher and a Subscription is not expected to be the active element in an established subscription.

      Verifies rule: 3.10

      Notes:

      • This could be tested with a synchronous source currently not available within the TCK.
      Throws:
      Exception

    • untested_spec311_blackbox_requestMaySynchronouslyCallOnCompleteOrOnError

      void untested_spec311_blackbox_requestMaySynchronouslyCallOnCompleteOrOnError() throws Exception
      Currently, this test is skipped because signal production is the responsibility of the Publisher and a Subscription is not expected to be the active element in an established subscription.

      Verifies rule: 3.11

      Notes:

      • Tests §2.9 and §2.10 are supposed to cover this case from the Subscriber's perspective.
      Throws:
      Exception

    • untested_spec314_blackbox_cancelMayCauseThePublisherToShutdownIfNoOtherSubscriptionExists

      void untested_spec314_blackbox_cancelMayCauseThePublisherToShutdownIfNoOtherSubscriptionExists() throws Exception
      Currently, this test is skipped because it is the responsibility of the Publisher deal with the case that all subscribers have cancelled their subscription.

      Verifies rule: 3.14

      Notes:

      • The specification lists this as an optional behavior because only some Publisher implementations (most likely Processors) would coordinate with multiple Subscribers.
      Throws:
      Exception

    • untested_spec315_blackbox_cancelMustNotThrowExceptionAndMustSignalOnError

      void untested_spec315_blackbox_cancelMustNotThrowExceptionAndMustSignalOnError() throws Exception
      Currently, this test is skipped because it requires more control over the Subscriber implementation thus there is no way to detect that the Subscriber called its own onError method in response to an exception thrown from Subscription.cancel.

      Verifies rule: 3.15

      Throws:
      Exception

    • untested_spec316_blackbox_requestMustNotThrowExceptionAndMustOnErrorTheSubscriber

      void untested_spec316_blackbox_requestMustNotThrowExceptionAndMustOnErrorTheSubscriber() throws Exception
      Currently, this test is skipped because it requires more control over the Subscriber implementation thus there is no way to detect that the Subscriber called its own onError method in response to an exception thrown from Subscription.request.

      Verifies rule: 3.16

      Throws:
      Exception