TestEnvironment (reactive-streams-tck 1.0.1 API)

java.lang.Object
- org.reactivestreams.tck.TestEnvironment

public class TestEnvironment
extends java.lang.Object

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`TestEnvironment.BlackholeSubscriberWithSubscriptionSupport<T>` Similar to `TestEnvironment.ManualSubscriberWithSubscriptionSupport` but does not accumulate values signalled via `onNext`, thus it can not be used to assert values signalled to this subscriber.
`static class`	`TestEnvironment.Latch` Like a CountDownLatch, but resettable and with some convenience methods
`static class`	`TestEnvironment.ManualPublisher<T>`
`static class`	`TestEnvironment.ManualSubscriber<T>` `Subscriber` implementation which can be steered by test code and asserted on.
`static class`	`TestEnvironment.ManualSubscriberWithSubscriptionSupport<T>`
`static class`	`TestEnvironment.Promise<T>`
`static class`	`TestEnvironment.Receptacle<T>`
`static class`	`TestEnvironment.TestSubscriber<T>`

Field Summary

Fields
Modifier and Type Field and Description

static int TEST_BUFFER_SIZE

Fields
Modifier and Type	Field and Description
`static int`	`TEST_BUFFER_SIZE`

Constructor Summary

Constructors
Constructor and Description
`TestEnvironment()` Tests must specify the timeout for expected outcome of asynchronous interactions.
`TestEnvironment(boolean printlnDebug)` Tests must specify the timeout for expected outcome of asynchronous interactions.
`TestEnvironment(long defaultTimeoutMillis)` Tests must specify the timeout for expected outcome of asynchronous interactions.
`TestEnvironment(long defaultTimeoutMillis, long defaultNoSignalsTimeoutMillis)` Tests must specify the timeout for expected outcome of asynchronous interactions.
`TestEnvironment(long defaultTimeoutMillis, long defaultNoSignalsTimeoutMillis, boolean printlnDebug)` Tests must specify the timeout for expected outcome of asynchronous interactions.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`clearAsyncErrors()`
`void`	`debug(java.lang.String msg)` If `TestEnvironment#printlnDebug` is true, print debug message to std out.
`long`	`defaultNoSignalsTimeoutMillis()` This timeout is used when asserting that no further signals are emitted.
`long`	`defaultTimeoutMillis()` This timeout is used when waiting for a signal to arrive.
`java.lang.Throwable`	`dropAsyncError()`
`static long`	`envDefaultNoSignalsTimeoutMillis()` Tries to parse the env variable `DEFAULT_NO_SIGNALS_TIMEOUT_MILLIS` as long and returns the value if present OR its default value.
`static long`	`envDefaultTimeoutMillis()` Tries to parse the env variable `DEFAULT_TIMEOUT_MILLIS` as long and returns the value if present OR its default value.
`Optional<java.lang.StackTraceElement>`	`findCallerMethodInStackTrace(java.lang.String method)` Looks for given `method` method in stack trace.
`void`	`flop(java.lang.String msg)` To flop means to "fail asynchronously", either by onErroring or by failing some TCK check triggered asynchronously.
`void`	`flop(java.lang.Throwable thr)` To flop means to "fail asynchronously", either by onErroring or by failing some TCK check triggered asynchronously.
`void`	`flop(java.lang.Throwable thr, java.lang.String msg)` To flop means to "fail asynchronously", either by onErroring or by failing some TCK check triggered asynchronously.
`<T> T`	`flopAndFail(java.lang.String msg)` To flop means to "fail asynchronously", either by onErroring or by failing some TCK check triggered asynchronously.
`<T> TestEnvironment.ManualSubscriber<T>`	`newBlackholeSubscriber(org.reactivestreams.Publisher<T> pub)`
`<T> TestEnvironment.ManualSubscriber<T>`	`newManualSubscriber(org.reactivestreams.Publisher<T> pub)`
`<T> TestEnvironment.ManualSubscriber<T>`	`newManualSubscriber(org.reactivestreams.Publisher<T> pub, long timeoutMillis)`
`<T> void`	`subscribe(org.reactivestreams.Publisher<T> pub, TestEnvironment.TestSubscriber<T> sub)`
`<T> void`	`subscribe(org.reactivestreams.Publisher<T> pub, TestEnvironment.TestSubscriber<T> sub, long timeoutMillis)`
`void`	`verifyNoAsyncErrors()` Waits for `defaultTimeoutMillis()` and then verifies that no asynchronous errors were signalled pior to, or during that time (by calling `flop()`).
`void`	`verifyNoAsyncErrors(long delay)` This version of `verifyNoAsyncErrors` should be used when errors still could be signalled asynchronously during `defaultTimeoutMillis()` time.
`void`	`verifyNoAsyncErrorsNoDelay()` Verifies that no asynchronous errors were signalled pior to calling this method (by calling `flop()`).

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - TEST_BUFFER_SIZE
```
public static final int TEST_BUFFER_SIZE
```
    See Also:
    
    Constant Field Values
- Constructor Detail
  - TestEnvironment
```
public TestEnvironment(long defaultTimeoutMillis,
                       long defaultNoSignalsTimeoutMillis,
                       boolean printlnDebug)
```
    Tests must specify the timeout for expected outcome of asynchronous interactions. Longer timeout does not invalidate the correctness of the implementation, but can in some cases result in longer time to run the tests.
    
    Parameters:
    
    defaultTimeoutMillis - default timeout to be used in all expect* methods
    
    defaultNoSignalsTimeoutMillis - default timeout to be used when no further signals are expected anymore
    
    printlnDebug - if true, signals such as OnNext / Request / OnComplete etc will be printed to standard output,
  - TestEnvironment
```
public TestEnvironment(long defaultTimeoutMillis,
                       long defaultNoSignalsTimeoutMillis)
```
    Tests must specify the timeout for expected outcome of asynchronous interactions. Longer timeout does not invalidate the correctness of the implementation, but can in some cases result in longer time to run the tests.
    
    Parameters:
    
    defaultTimeoutMillis - default timeout to be used in all expect* methods
    
    defaultNoSignalsTimeoutMillis - default timeout to be used when no further signals are expected anymore
  - TestEnvironment
```
public TestEnvironment(long defaultTimeoutMillis)
```
    Tests must specify the timeout for expected outcome of asynchronous interactions. Longer timeout does not invalidate the correctness of the implementation, but can in some cases result in longer time to run the tests.
    
    Parameters:
    
    defaultTimeoutMillis - default timeout to be used in all expect* methods
  - TestEnvironment
```
public TestEnvironment(boolean printlnDebug)
```
    Tests must specify the timeout for expected outcome of asynchronous interactions. Longer timeout does not invalidate the correctness of the implementation, but can in some cases result in longer time to run the tests. The default timeout for all expect* methods will be obtained by either the env variable DEFAULT_TIMEOUT_MILLIS or the default value (DEFAULT_TIMEOUT_MILLIS) will be used.
    
    Parameters:
    
    printlnDebug - if true, signals such as OnNext / Request / OnComplete etc will be printed to standard output, often helpful to pinpoint simple race conditions etc.
  - TestEnvironment
```
public TestEnvironment()
```
    Tests must specify the timeout for expected outcome of asynchronous interactions. Longer timeout does not invalidate the correctness of the implementation, but can in some cases result in longer time to run the tests. The default timeout for all expect* methods will be obtained by either the env variable DEFAULT_TIMEOUT_MILLIS or the default value (DEFAULT_TIMEOUT_MILLIS) will be used.
- Method Detail
  - defaultTimeoutMillis
```
public long defaultTimeoutMillis()
```
    This timeout is used when waiting for a signal to arrive.
  - defaultNoSignalsTimeoutMillis
```
public long defaultNoSignalsTimeoutMillis()
```
    This timeout is used when asserting that no further signals are emitted. Note that this timeout default
  - envDefaultTimeoutMillis
```
public static long envDefaultTimeoutMillis()
```
    Tries to parse the env variable DEFAULT_TIMEOUT_MILLIS as long and returns the value if present OR its default value.
    
    Throws:
    
    java.lang.IllegalArgumentException - when unable to parse the env variable
  - envDefaultNoSignalsTimeoutMillis
```
public static long envDefaultNoSignalsTimeoutMillis()
```
    Tries to parse the env variable DEFAULT_NO_SIGNALS_TIMEOUT_MILLIS as long and returns the value if present OR its default value.
    
    Throws:
    
    java.lang.IllegalArgumentException - when unable to parse the env variable
  - flop
```
public void flop(java.lang.String msg)
```
    To flop means to "fail asynchronously", either by onErroring or by failing some TCK check triggered asynchronously. This method does *NOT* fail the test - it's up to inspections of the error to fail the test if required. Use env.verifyNoAsyncErrorsNoDelay() at the end of your TCK tests to verify there no flops called during it's execution. To check investigate asyncErrors more closely you can use expectError methods or collect the error directly from the environment using env.dropAsyncError(). To clear asyncErrors you can call clearAsyncErrors()
  - flop
```
public void flop(java.lang.Throwable thr,
                 java.lang.String msg)
```
    To flop means to "fail asynchronously", either by onErroring or by failing some TCK check triggered asynchronously. This method does *NOT* fail the test - it's up to inspections of the error to fail the test if required. This overload keeps the passed in throwable as the asyncError, instead of creating an AssertionError for this. Use env.verifyNoAsyncErrorsNoDelay() at the end of your TCK tests to verify there no flops called during it's execution. To check investigate asyncErrors more closely you can use expectError methods or collect the error directly from the environment using env.dropAsyncError(). To clear asyncErrors you can call clearAsyncErrors()
  - flop
```
public void flop(java.lang.Throwable thr)
```
    To flop means to "fail asynchronously", either by onErroring or by failing some TCK check triggered asynchronously. This method does *NOT* fail the test - it's up to inspections of the error to fail the test if required. This overload keeps the passed in throwable as the asyncError, instead of creating an AssertionError for this. Use env.verifyNoAsyncErrorsNoDelay() at the end of your TCK tests to verify there no flops called during it's execution. To check investigate asyncErrors more closely you can use expectError methods or collect the error directly from the environment using env.dropAsyncError(). To clear asyncErrors you can call clearAsyncErrors()
  - flopAndFail
```
public <T> T flopAndFail(java.lang.String msg)
```
    To flop means to "fail asynchronously", either by onErroring or by failing some TCK check triggered asynchronously. This method DOES fail the test right away (it tries to, by throwing an AssertionException), in such it is different from flop(java.lang.String) which only records the error. Use env.verifyNoAsyncErrorsNoDelay() at the end of your TCK tests to verify there no flops called during it's execution. To check investigate asyncErrors more closely you can use expectError methods or collect the error directly from the environment using env.dropAsyncError(). To clear asyncErrors you can call clearAsyncErrors()
  - subscribe
```
public <T> void subscribe(org.reactivestreams.Publisher<T> pub,
                          TestEnvironment.TestSubscriber<T> sub)
                   throws java.lang.InterruptedException
```
    Throws:
    
    java.lang.InterruptedException
  - subscribe
```
public <T> void subscribe(org.reactivestreams.Publisher<T> pub,
                          TestEnvironment.TestSubscriber<T> sub,
                          long timeoutMillis)
                   throws java.lang.InterruptedException
```
    Throws:
    
    java.lang.InterruptedException
  - newBlackholeSubscriber
```
public <T> TestEnvironment.ManualSubscriber<T> newBlackholeSubscriber(org.reactivestreams.Publisher<T> pub)
                                                               throws java.lang.InterruptedException
```
    Throws:
    
    java.lang.InterruptedException
  - newManualSubscriber
```
public <T> TestEnvironment.ManualSubscriber<T> newManualSubscriber(org.reactivestreams.Publisher<T> pub)
                                                            throws java.lang.InterruptedException
```
    Throws:
    
    java.lang.InterruptedException
  - newManualSubscriber
```
public <T> TestEnvironment.ManualSubscriber<T> newManualSubscriber(org.reactivestreams.Publisher<T> pub,
                                                                   long timeoutMillis)
                                                            throws java.lang.InterruptedException
```
    Throws:
    
    java.lang.InterruptedException
  - clearAsyncErrors
```
public void clearAsyncErrors()
```
  - dropAsyncError
```
public java.lang.Throwable dropAsyncError()
```
  - verifyNoAsyncErrors
```
public void verifyNoAsyncErrors()
```
    Waits for defaultTimeoutMillis() and then verifies that no asynchronous errors were signalled pior to, or during that time (by calling flop()).
  - verifyNoAsyncErrors
```
public void verifyNoAsyncErrors(long delay)
```
    This version of verifyNoAsyncErrors should be used when errors still could be signalled asynchronously during defaultTimeoutMillis() time.
    It will immediatly check if any async errors were signaled (using flop(String), and if no errors encountered wait for another default timeout as the errors may yet be signalled. The initial check is performed in order to fail-fast in case of an already failed test.
  - verifyNoAsyncErrorsNoDelay
```
public void verifyNoAsyncErrorsNoDelay()
```
    Verifies that no asynchronous errors were signalled pior to calling this method (by calling flop()). This version of verifyNoAsyncError does not wait before checking for asynchronous errors, and is to be used for example in tight loops etc.
  - debug
```
public void debug(java.lang.String msg)
```
    If TestEnvironment#printlnDebug is true, print debug message to std out.
  - findCallerMethodInStackTrace
```
public Optional<java.lang.StackTraceElement> findCallerMethodInStackTrace(java.lang.String method)
```
    Looks for given method method in stack trace. Can be used to answer questions like "was this method called from onComplete?".
    
    Returns:
    
    the caller's StackTraceElement at which he the looked for method was found in the call stack, EMPTY otherwise

Class TestEnvironment

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

TEST_BUFFER_SIZE

Constructor Detail

TestEnvironment

TestEnvironment

TestEnvironment

TestEnvironment

TestEnvironment

Method Detail

defaultTimeoutMillis

defaultNoSignalsTimeoutMillis

envDefaultTimeoutMillis

envDefaultNoSignalsTimeoutMillis

flop

flop

flop

flopAndFail

subscribe

subscribe

newBlackholeSubscriber

newManualSubscriber

newManualSubscriber

clearAsyncErrors

dropAsyncError

verifyNoAsyncErrors

verifyNoAsyncErrors

verifyNoAsyncErrorsNoDelay

debug

findCallerMethodInStackTrace