Class SubscriberBlackboxVerification<T>

java.lang.Object

org.reactivestreams.tck.WithHelperPublisher<T>

org.reactivestreams.tck.SubscriberBlackboxVerification<T>

All Implemented Interfaces:

SubscriberBlackboxVerificationRules

Direct Known Subclasses:

FlowSubscriberBlackboxVerification

public abstract class SubscriberBlackboxVerification<T>
extends WithHelperPublisher<T>
implements SubscriberBlackboxVerificationRules

Provides tests for verifying Subscriber and Subscription specification rules, without any modifications to the tested implementation (also known as "Black Box" testing). This verification is NOT able to check many of the rules of the spec, and if you want more verification of your implementation you'll have to implement org.reactivestreams.tck.SubscriberWhiteboxVerification instead.

See Also:

• Subscriber
• Subscription

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
class	SubscriberBlackboxVerification.BlackboxTestStage
(package private) class	SubscriberBlackboxVerification.BlackboxTestStageTestRun	//////////////////// TEST INFRASTRUCTURE /////////////////////////////////

Field Summary

Fields

Modifier and Type	Field	Description
protected final TestEnvironment	env
private ExecutorService	publisherExecutor	Executor service used by the default provided asynchronous Publisher.

Constructor Summary

Constructors

Modifier	Constructor	Description
protected	SubscriberBlackboxVerification(TestEnvironment env)

Method Summary

Modifier and Type	Method	Description
void	blackboxSubscriberTest(SubscriberBlackboxVerification<T>.BlackboxTestStageTestRun body)
void	blackboxSubscriberWithoutSetupTest(SubscriberBlackboxVerification<T>.BlackboxTestStageTestRun body)
abstract Subscriber<T>	createSubscriber()	This is the main method you must implement in your test incarnation.
void	notVerified()
ExecutorService	publisherExecutorService()	ExecutorService to be used by the provided helper Publisher
void	required_spec201_blackbox_mustSignalDemandViaSubscriptionRequest()	/////////////////// SPEC RULE VERIFICATION ///////////////////////////////
void	required_spec203_blackbox_mustNotCallMethodsOnSubscriptionOrPublisherInOnComplete()	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.
void	required_spec203_blackbox_mustNotCallMethodsOnSubscriptionOrPublisherInOnError()	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.
void	required_spec205_blackbox_mustCallSubscriptionCancelIfItAlreadyHasAnSubscriptionAndReceivesAnotherOnSubscribeSignal()	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.
void	required_spec209_blackbox_mustBePreparedToReceiveAnOnCompleteSignalWithoutPrecedingRequestCall()	Asks for a Subscriber and expects it to handle onComplete independent of whether the Subscriber requests items or not.
void	required_spec209_blackbox_mustBePreparedToReceiveAnOnCompleteSignalWithPrecedingRequestCall()	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.
void	required_spec210_blackbox_mustBePreparedToReceiveAnOnErrorSignalWithoutPrecedingRequestCall()	Asks for a Subscriber, signals onSubscribe followed by an onError synchronously.
void	required_spec210_blackbox_mustBePreparedToReceiveAnOnErrorSignalWithPrecedingRequestCall()	Asks for a Subscriber, signals onSubscribe followed by an onError synchronously.
void	required_spec213_blackbox_onError_mustThrowNullPointerExceptionWhenParametersAreNull()	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.
void	required_spec213_blackbox_onNext_mustThrowNullPointerExceptionWhenParametersAreNull()	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.
void	required_spec213_blackbox_onSubscribe_mustThrowNullPointerExceptionWhenParametersAreNull()	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.
void	setUp()	/////////////////// TEST ENV CLEANUP /////////////////////////////////////
void	shutdownPublisherExecutorService()
void	startPublisherExecutorService()
void	triggerRequest(Subscriber<? super T> subscriber)	Override this method if the Subscriber implementation you are verifying needs an external signal before it signals demand to its Publisher.
void	untested_spec202_blackbox_shouldAsynchronouslyDispatch()	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.
void	untested_spec204_blackbox_mustConsiderTheSubscriptionAsCancelledInAfterRecievingOnCompleteOrOnError()	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.
void	untested_spec206_blackbox_mustCallSubscriptionCancelIfItIsNoLongerValid()	Currently, this test is skipped because it requires more control over the Subscriber implementation to make it cancel the Subscription for some external condition.
void	untested_spec207_blackbox_mustEnsureAllCallsOnItsSubscriptionTakePlaceFromTheSameThreadOrTakeCareOfSynchronization()	Currently, this test is skipped because it requires more control over the Subscriber implementation to issue requests based on external stimulus.
void	untested_spec208_blackbox_mustBePreparedToReceiveOnNextSignalsAfterHavingCalledSubscriptionCancel()	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.
void	untested_spec211_blackbox_mustMakeSureThatAllCallsOnItsMethodsHappenBeforeTheProcessingOfTheRespectiveEvents()	Currently, this test is skipped because it would require analyzing what the Subscriber implementation does.
void	untested_spec212_blackbox_mustNotCallOnSubscribeMoreThanOnceBasedOnObjectEquality()	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.
void	untested_spec213_blackbox_failingOnSignalInvocation()	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.
void	untested_spec301_blackbox_mustNotBeCalledOutsideSubscriberContext()	/////////////////// SUBSCRIPTION SPEC RULE VERIFICATION //////////////////
void	untested_spec308_blackbox_requestMustRegisterGivenNumberElementsToBeProduced()	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.
void	untested_spec310_blackbox_requestMaySynchronouslyCallOnNextOnSubscriber()	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.
void	untested_spec311_blackbox_requestMaySynchronouslyCallOnCompleteOrOnError()	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.
void	untested_spec314_blackbox_cancelMayCauseThePublisherToShutdownIfNoOtherSubscriptionExists()	Currently, this test is skipped because it is the responsibility of the Publisher deal with the case that all subscribers have cancelled their subscription.
void	untested_spec315_blackbox_cancelMustNotThrowExceptionAndMustSignalOnError()	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.
void	untested_spec316_blackbox_requestMustNotThrowExceptionAndMustOnErrorTheSubscriber()	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.

Methods inherited from class WithHelperPublisher

createElement, createHelperPublisher

Methods inherited from class Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Details

env

protected final TestEnvironment env

publisherExecutor

private ExecutorService publisherExecutor

Executor service used by the default provided asynchronous Publisher.

See Also:

• WithHelperPublisher.createHelperPublisher(long)

Constructor Details

SubscriberBlackboxVerification

protected SubscriberBlackboxVerification(TestEnvironment env)

Method Details

createSubscriber

public abstract Subscriber<T> createSubscriber()

This is the main method you must implement in your test incarnation. It must create a new Subscriber instance to be subjected to the testing logic.

triggerRequest

public void triggerRequest(Subscriber<? super T> subscriber)

Override this method if the Subscriber implementation you are verifying needs an external signal before it signals demand to its Publisher. By default this method does nothing.

startPublisherExecutorService

@BeforeClass
public void startPublisherExecutorService()

shutdownPublisherExecutorService

@AfterClass
public void shutdownPublisherExecutorService()

publisherExecutorService

public ExecutorService publisherExecutorService()

Description copied from class: WithHelperPublisher

ExecutorService to be used by the provided helper Publisher

Specified by:

publisherExecutorService in class WithHelperPublisher<T>

setUp

@BeforeMethod
public void setUp()
           throws Exception

/////////////////// TEST ENV CLEANUP /////////////////////////////////////

Throws:

Exception

required_spec201_blackbox_mustSignalDemandViaSubscriptionRequest

public void required_spec201_blackbox_mustSignalDemandViaSubscriptionRequest()
                                                                      throws Throwable

/////////////////// SPEC RULE VERIFICATION ///////////////////////////////

Specified by:

required_spec201_blackbox_mustSignalDemandViaSubscriptionRequest in interface SubscriberBlackboxVerificationRules

Throws:

Throwable

untested_spec202_blackbox_shouldAsynchronouslyDispatch

public void untested_spec202_blackbox_shouldAsynchronouslyDispatch()
                                                            throws Exception

Description copied from interface: SubscriberBlackboxVerificationRules

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

Specified by:

untested_spec202_blackbox_shouldAsynchronouslyDispatch in interface SubscriberBlackboxVerificationRules

Throws:

Exception

required_spec203_blackbox_mustNotCallMethodsOnSubscriptionOrPublisherInOnComplete

public void required_spec203_blackbox_mustNotCallMethodsOnSubscriptionOrPublisherInOnComplete()
                                                                                       throws Throwable

Description copied from interface: SubscriberBlackboxVerificationRules

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.

Specified by:

required_spec203_blackbox_mustNotCallMethodsOnSubscriptionOrPublisherInOnComplete in interface SubscriberBlackboxVerificationRules

Throws:

Throwable

required_spec203_blackbox_mustNotCallMethodsOnSubscriptionOrPublisherInOnError

public void required_spec203_blackbox_mustNotCallMethodsOnSubscriptionOrPublisherInOnError()
                                                                                    throws Throwable

Description copied from interface: SubscriberBlackboxVerificationRules

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.

Specified by:

required_spec203_blackbox_mustNotCallMethodsOnSubscriptionOrPublisherInOnError in interface SubscriberBlackboxVerificationRules

Throws:

Throwable

untested_spec204_blackbox_mustConsiderTheSubscriptionAsCancelledInAfterRecievingOnCompleteOrOnError

public void untested_spec204_blackbox_mustConsiderTheSubscriptionAsCancelledInAfterRecievingOnCompleteOrOnError()
                                                                                                         throws Exception

Description copied from interface: SubscriberBlackboxVerificationRules

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.

Specified by:

untested_spec204_blackbox_mustConsiderTheSubscriptionAsCancelledInAfterRecievingOnCompleteOrOnError in interface SubscriberBlackboxVerificationRules

Throws:

Exception

required_spec205_blackbox_mustCallSubscriptionCancelIfItAlreadyHasAnSubscriptionAndReceivesAnotherOnSubscribeSignal

public void required_spec205_blackbox_mustCallSubscriptionCancelIfItAlreadyHasAnSubscriptionAndReceivesAnotherOnSubscribeSignal()
                                                                                                                         throws Exception

Description copied from interface: SubscriberBlackboxVerificationRules

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.

Specified by:

required_spec205_blackbox_mustCallSubscriptionCancelIfItAlreadyHasAnSubscriptionAndReceivesAnotherOnSubscribeSignal in interface SubscriberBlackboxVerificationRules

Throws:

Exception

untested_spec206_blackbox_mustCallSubscriptionCancelIfItIsNoLongerValid

public void untested_spec206_blackbox_mustCallSubscriptionCancelIfItIsNoLongerValid()
                                                                             throws Exception

Description copied from interface: SubscriberBlackboxVerificationRules

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

Specified by:

untested_spec206_blackbox_mustCallSubscriptionCancelIfItIsNoLongerValid in interface SubscriberBlackboxVerificationRules

Throws:

Exception

untested_spec207_blackbox_mustEnsureAllCallsOnItsSubscriptionTakePlaceFromTheSameThreadOrTakeCareOfSynchronization

public void untested_spec207_blackbox_mustEnsureAllCallsOnItsSubscriptionTakePlaceFromTheSameThreadOrTakeCareOfSynchronization()
                                                                                                                        throws Exception

Description copied from interface: SubscriberBlackboxVerificationRules

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

Specified by:

untested_spec207_blackbox_mustEnsureAllCallsOnItsSubscriptionTakePlaceFromTheSameThreadOrTakeCareOfSynchronization in interface SubscriberBlackboxVerificationRules

Throws:

Exception

untested_spec208_blackbox_mustBePreparedToReceiveOnNextSignalsAfterHavingCalledSubscriptionCancel

public void untested_spec208_blackbox_mustBePreparedToReceiveOnNextSignalsAfterHavingCalledSubscriptionCancel()
                                                                                                       throws Throwable

Description copied from interface: SubscriberBlackboxVerificationRules

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

Specified by:

untested_spec208_blackbox_mustBePreparedToReceiveOnNextSignalsAfterHavingCalledSubscriptionCancel in interface SubscriberBlackboxVerificationRules

Throws:

Throwable

required_spec209_blackbox_mustBePreparedToReceiveAnOnCompleteSignalWithPrecedingRequestCall

public void required_spec209_blackbox_mustBePreparedToReceiveAnOnCompleteSignalWithPrecedingRequestCall()
                                                                                                 throws Throwable

Description copied from interface: SubscriberBlackboxVerificationRules

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:

• if the Subscriber throws an unchecked exception from its onSubscribe or onComplete methods.
• if the Subscriber requires external stimulus to begin requesting; override the triggerRequest(org.reactivestreams.Subscriber) method in this case,

Specified by:

required_spec209_blackbox_mustBePreparedToReceiveAnOnCompleteSignalWithPrecedingRequestCall in interface SubscriberBlackboxVerificationRules

Throws:

Throwable

required_spec209_blackbox_mustBePreparedToReceiveAnOnCompleteSignalWithoutPrecedingRequestCall

public void required_spec209_blackbox_mustBePreparedToReceiveAnOnCompleteSignalWithoutPrecedingRequestCall()
                                                                                                    throws Throwable

Description copied from interface: SubscriberBlackboxVerificationRules

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.

Specified by:

required_spec209_blackbox_mustBePreparedToReceiveAnOnCompleteSignalWithoutPrecedingRequestCall in interface SubscriberBlackboxVerificationRules

Throws:

Throwable

required_spec210_blackbox_mustBePreparedToReceiveAnOnErrorSignalWithPrecedingRequestCall

public void required_spec210_blackbox_mustBePreparedToReceiveAnOnErrorSignalWithPrecedingRequestCall()
                                                                                              throws Throwable

Description copied from interface: SubscriberBlackboxVerificationRules

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.

Specified by:

required_spec210_blackbox_mustBePreparedToReceiveAnOnErrorSignalWithPrecedingRequestCall in interface SubscriberBlackboxVerificationRules

Throws:

Throwable

required_spec210_blackbox_mustBePreparedToReceiveAnOnErrorSignalWithoutPrecedingRequestCall

public void required_spec210_blackbox_mustBePreparedToReceiveAnOnErrorSignalWithoutPrecedingRequestCall()
                                                                                                 throws Throwable

Description copied from interface: SubscriberBlackboxVerificationRules

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.

Specified by:

required_spec210_blackbox_mustBePreparedToReceiveAnOnErrorSignalWithoutPrecedingRequestCall in interface SubscriberBlackboxVerificationRules

Throws:

Throwable

untested_spec211_blackbox_mustMakeSureThatAllCallsOnItsMethodsHappenBeforeTheProcessingOfTheRespectiveEvents

public void untested_spec211_blackbox_mustMakeSureThatAllCallsOnItsMethodsHappenBeforeTheProcessingOfTheRespectiveEvents()
                                                                                                                  throws Exception

Description copied from interface: SubscriberBlackboxVerificationRules

Currently, this test is skipped because it would require analyzing what the Subscriber implementation does.

Verifies rule: 2.11

Specified by:

untested_spec211_blackbox_mustMakeSureThatAllCallsOnItsMethodsHappenBeforeTheProcessingOfTheRespectiveEvents in interface SubscriberBlackboxVerificationRules

Throws:

Exception

untested_spec212_blackbox_mustNotCallOnSubscribeMoreThanOnceBasedOnObjectEquality

public void untested_spec212_blackbox_mustNotCallOnSubscribeMoreThanOnceBasedOnObjectEquality()
                                                                                       throws Throwable

Description copied from interface: SubscriberBlackboxVerificationRules

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.

Specified by:

untested_spec212_blackbox_mustNotCallOnSubscribeMoreThanOnceBasedOnObjectEquality in interface SubscriberBlackboxVerificationRules

Throws:

Throwable

untested_spec213_blackbox_failingOnSignalInvocation

public void untested_spec213_blackbox_failingOnSignalInvocation()
                                                         throws Exception

Description copied from interface: SubscriberBlackboxVerificationRules

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

Specified by:

untested_spec213_blackbox_failingOnSignalInvocation in interface SubscriberBlackboxVerificationRules

Throws:

Exception

required_spec213_blackbox_onSubscribe_mustThrowNullPointerExceptionWhenParametersAreNull

public void required_spec213_blackbox_onSubscribe_mustThrowNullPointerExceptionWhenParametersAreNull()
                                                                                              throws Throwable

Description copied from interface: SubscriberBlackboxVerificationRules

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.

Specified by:

required_spec213_blackbox_onSubscribe_mustThrowNullPointerExceptionWhenParametersAreNull in interface SubscriberBlackboxVerificationRules

Throws:

Throwable

required_spec213_blackbox_onNext_mustThrowNullPointerExceptionWhenParametersAreNull

public void required_spec213_blackbox_onNext_mustThrowNullPointerExceptionWhenParametersAreNull()
                                                                                         throws Throwable

Description copied from interface: SubscriberBlackboxVerificationRules

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.

Specified by:

required_spec213_blackbox_onNext_mustThrowNullPointerExceptionWhenParametersAreNull in interface SubscriberBlackboxVerificationRules

Throws:

Throwable

required_spec213_blackbox_onError_mustThrowNullPointerExceptionWhenParametersAreNull

public void required_spec213_blackbox_onError_mustThrowNullPointerExceptionWhenParametersAreNull()
                                                                                          throws Throwable

Description copied from interface: SubscriberBlackboxVerificationRules

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.

Specified by:

required_spec213_blackbox_onError_mustThrowNullPointerExceptionWhenParametersAreNull in interface SubscriberBlackboxVerificationRules

Throws:

Throwable

untested_spec301_blackbox_mustNotBeCalledOutsideSubscriberContext

public void untested_spec301_blackbox_mustNotBeCalledOutsideSubscriberContext()
                                                                       throws Exception

/////////////////// SUBSCRIPTION SPEC RULE VERIFICATION //////////////////

Specified by:

untested_spec301_blackbox_mustNotBeCalledOutsideSubscriberContext in interface SubscriberBlackboxVerificationRules

Throws:

Exception

untested_spec308_blackbox_requestMustRegisterGivenNumberElementsToBeProduced

public void untested_spec308_blackbox_requestMustRegisterGivenNumberElementsToBeProduced()
                                                                                  throws Throwable

Description copied from interface: SubscriberBlackboxVerificationRules

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

Specified by:

untested_spec308_blackbox_requestMustRegisterGivenNumberElementsToBeProduced in interface SubscriberBlackboxVerificationRules

Throws:

Throwable

untested_spec310_blackbox_requestMaySynchronouslyCallOnNextOnSubscriber

public void untested_spec310_blackbox_requestMaySynchronouslyCallOnNextOnSubscriber()
                                                                             throws Exception

Description copied from interface: SubscriberBlackboxVerificationRules

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.

Specified by:

untested_spec310_blackbox_requestMaySynchronouslyCallOnNextOnSubscriber in interface SubscriberBlackboxVerificationRules

Throws:

Exception

untested_spec311_blackbox_requestMaySynchronouslyCallOnCompleteOrOnError

public void untested_spec311_blackbox_requestMaySynchronouslyCallOnCompleteOrOnError()
                                                                              throws Exception

Description copied from interface: SubscriberBlackboxVerificationRules

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.

Specified by:

untested_spec311_blackbox_requestMaySynchronouslyCallOnCompleteOrOnError in interface SubscriberBlackboxVerificationRules

Throws:

Exception

untested_spec314_blackbox_cancelMayCauseThePublisherToShutdownIfNoOtherSubscriptionExists

public void untested_spec314_blackbox_cancelMayCauseThePublisherToShutdownIfNoOtherSubscriptionExists()
                                                                                               throws Exception

Description copied from interface: SubscriberBlackboxVerificationRules

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.

Specified by:

untested_spec314_blackbox_cancelMayCauseThePublisherToShutdownIfNoOtherSubscriptionExists in interface SubscriberBlackboxVerificationRules

Throws:

Exception

untested_spec315_blackbox_cancelMustNotThrowExceptionAndMustSignalOnError

public void untested_spec315_blackbox_cancelMustNotThrowExceptionAndMustSignalOnError()
                                                                               throws Exception

Description copied from interface: SubscriberBlackboxVerificationRules

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

Specified by:

untested_spec315_blackbox_cancelMustNotThrowExceptionAndMustSignalOnError in interface SubscriberBlackboxVerificationRules

Throws:

Exception

untested_spec316_blackbox_requestMustNotThrowExceptionAndMustOnErrorTheSubscriber

public void untested_spec316_blackbox_requestMustNotThrowExceptionAndMustOnErrorTheSubscriber()
                                                                                       throws Exception

Description copied from interface: SubscriberBlackboxVerificationRules

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

Specified by:

untested_spec316_blackbox_requestMustNotThrowExceptionAndMustOnErrorTheSubscriber in interface SubscriberBlackboxVerificationRules

Throws:

Exception

blackboxSubscriberTest

public void blackboxSubscriberTest(SubscriberBlackboxVerification<T>.BlackboxTestStageTestRun body)
                            throws Throwable

Throws:

Throwable

blackboxSubscriberWithoutSetupTest

public void blackboxSubscriberWithoutSetupTest(SubscriberBlackboxVerification<T>.BlackboxTestStageTestRun body)
                                        throws Throwable

Throws:

Throwable

notVerified

public void notVerified()