+TCK verifyNoAsyncErrors now by default waits, fixes spec111

ktoso · ktoso · commit d7a2e1dd9813 · 2015-03-25T00:07:07.000+01:00
Resolves #239
diff --git a/tck/src/main/java/org/reactivestreams/tck/IdentityProcessorVerification.java b/tck/src/main/java/org/reactivestreams/tck/IdentityProcessorVerification.java
@@ -408,7 +408,7 @@ public TestSetup apply(Long aLong) throws Throwable {
           sub1.expectError(ex);
           sub2.expectError(ex);
 
-          env.verifyNoAsyncErrors();
+          env.verifyNoAsyncErrorsNoDelay();
         }};
       }
     });
@@ -480,7 +480,7 @@ public void mustImmediatelyPassOnOnErrorEventsReceivedFromItsUpstreamToItsDownst
       sendError(ex);
       sub.expectError(ex); // "immediately", i.e. without a preceding request
 
-      env.verifyNoAsyncErrors();
+      env.verifyNoAsyncErrorsNoDelay();
     }};
   }
 
@@ -668,7 +668,7 @@ public TestSetup apply(Long subscribers) throws Throwable {
           sub1.expectCompletion(env.defaultTimeoutMillis());
           sub2.expectCompletion(env.defaultTimeoutMillis());
 
-          env.verifyNoAsyncErrors();
+          env.verifyNoAsyncErrorsNoDelay();
         }};
       }
     });
diff --git a/tck/src/main/java/org/reactivestreams/tck/PublisherVerification.java b/tck/src/main/java/org/reactivestreams/tck/PublisherVerification.java
@@ -460,9 +460,10 @@ public void run(Publisher<T> pub) throws Throwable {
         try {
             pub.subscribe(null);
             env.flop("Publisher did not throw a NullPointerException when given a null Subscribe in subscribe");
-        } catch (NullPointerException npe) {
+        } catch (NullPointerException ignored) {
+          // valid behaviour
         }
-        env.verifyNoAsyncErrors();
+        env.verifyNoAsyncErrorsNoDelay();
       }
     });
   }
@@ -497,7 +498,7 @@ public void onComplete() {
           }
         });
         onSubscribeLatch.expectClose("Should have received onSubscribe");
-        env.verifyNoAsyncErrors();
+        env.verifyNoAsyncErrorsNoDelay();
       }
     });
   }
@@ -528,7 +529,7 @@ public void onSubscribe(Subscription subs) {
         onSubscribeLatch.expectClose("Should have received onSubscribe");
         onErrorLatch.expectClose("Should have received onError");
 
-        env.verifyNoAsyncErrors();
+        env.verifyNoAsyncErrorsNoDelay();
       }
     });
   }
@@ -777,7 +778,7 @@ public void onError(Throwable cause) {
                                                "awaited at-most %s signals (`maxOnNextSignalsInRecursionTest()`) or completion",
                                            oneMoreThanBoundedLimit);
           runCompleted.expectClose(env.defaultTimeoutMillis(), msg);
-          env.verifyNoAsyncErrors();
+          env.verifyNoAsyncErrorsNoDelay();
         } finally {
           // since the request/onNext recursive calls may keep the publisher running "forever",
           // we MUST cancel it manually before exiting this test case
@@ -828,7 +829,7 @@ public void cancel() {
         sub.request(1);
 
         sub.expectNone();
-        env.verifyNoAsyncErrors();
+        env.verifyNoAsyncErrorsNoDelay();
       }
     });
   }
@@ -849,7 +850,7 @@ public void run(Publisher<T> pub) throws Throwable {
         subs.cancel();
 
         sub.expectNone();
-        env.verifyNoAsyncErrors();
+        env.verifyNoAsyncErrorsNoDelay();
       }
     });
   }
@@ -940,7 +941,7 @@ > AsyncPublisher receives cancel() - handles it right away, by "stopping itself"
       }
     });
 
-    env.verifyNoAsyncErrors();
+    env.verifyNoAsyncErrorsNoDelay();
   }
 
   // Verifies rule: https://github.com/reactive-streams/reactive-streams#3.13
@@ -976,7 +977,7 @@ public void run(Publisher<T> pub) throws Throwable {
           env.flop(String.format("Publisher %s did not drop reference to test subscriber after subscription cancellation", pub));
         }
 
-        env.verifyNoAsyncErrors();
+        env.verifyNoAsyncErrorsNoDelay();
       }
     });
   }
@@ -995,7 +996,7 @@ public void run(Publisher<T> pub) throws Throwable {
         sub.nextElements(totalElements);
         sub.expectCompletion();
 
-        env.verifyNoAsyncErrors();
+        env.verifyNoAsyncErrorsNoDelay();
       }
     });
   }
@@ -1017,7 +1018,7 @@ public void run(Publisher<T> pub) throws Throwable {
         sub.expectCompletion();
 
         try {
-          env.verifyNoAsyncErrors();
+          env.verifyNoAsyncErrorsNoDelay();
         } finally {
           sub.cancel();
         }
@@ -1090,7 +1091,7 @@ public void activePublisherTest(long elements, boolean completionSignalRequired,
     } else {
       Publisher<T> pub = createPublisher(elements);
       body.run(pub);
-      env.verifyNoAsyncErrors();
+      env.verifyNoAsyncErrorsNoDelay();
     }
   }
 
diff --git a/tck/src/main/java/org/reactivestreams/tck/SubscriberBlackboxVerification.java b/tck/src/main/java/org/reactivestreams/tck/SubscriberBlackboxVerification.java
@@ -121,7 +121,7 @@ public void cancel() {
         sub.onSubscribe(subs);
         sub.onComplete();
 
-        env.verifyNoAsyncErrors();
+        env.verifyNoAsyncErrorsNoDelay();
       }
     });
   }
@@ -160,7 +160,7 @@ public void cancel() {
         sub.onSubscribe(subs);
         sub.onError(new TestException());
 
-        env.verifyNoAsyncErrors();
+        env.verifyNoAsyncErrorsNoDelay();
       }
     });
   }
@@ -196,7 +196,7 @@ public String toString() {
           });
 
       secondSubscriptionCancelled.expectClose("Expected SecondSubscription given to subscriber to be cancelled, but `Subscription.cancel()` was not called.");
-      env.verifyNoAsyncErrors();
+      env.verifyNoAsyncErrorsNoDelay();
     }};
   }
 
@@ -251,7 +251,7 @@ public void run(BlackboxTestStage stage) throws Throwable {
         probe.expectCompletion();
         probe.expectNone();
 
-        env.verifyNoAsyncErrors();
+        env.verifyNoAsyncErrorsNoDelay();
       }
     });
   }
@@ -275,7 +275,7 @@ public void subscribe(Subscriber<? super T> s) {
         pub.subscribe(probe);
         probe.expectCompletion();
 
-        env.verifyNoAsyncErrors();
+        env.verifyNoAsyncErrorsNoDelay();
       }
     });
   }
@@ -329,7 +329,7 @@ public void run(BlackboxTestStage stage) throws Throwable {
           assertTrue(gotNPE, "onSubscribe(null) did not throw NullPointerException");
         }
 
-        env.verifyNoAsyncErrors();
+        env.verifyNoAsyncErrorsNoDelay();
       }
     });
   }
@@ -357,7 +357,7 @@ public void run(BlackboxTestStage stage) throws Throwable {
           assertTrue(gotNPE, "onNext(null) did not throw NullPointerException");
         }
 
-        env.verifyNoAsyncErrors();
+        env.verifyNoAsyncErrorsNoDelay();
       }
     });
   }
@@ -385,7 +385,7 @@ public void run(BlackboxTestStage stage) throws Throwable {
           assertTrue(gotNPE, "onError(null) did not throw NullPointerException");
         }
 
-        env.verifyNoAsyncErrors();
+        env.verifyNoAsyncErrorsNoDelay();
       }
     });
   }
diff --git a/tck/src/main/java/org/reactivestreams/tck/SubscriberWhiteboxVerification.java b/tck/src/main/java/org/reactivestreams/tck/SubscriberWhiteboxVerification.java
@@ -149,7 +149,7 @@ public void cancel() {
         sub.onSubscribe(subs);
         sub.onComplete();
 
-        env.verifyNoAsyncErrors();
+        env.verifyNoAsyncErrorsNoDelay();
       }
     });
   }
@@ -190,7 +190,7 @@ public void cancel() {
         sub.onSubscribe(subs);
         sub.onError(new TestException());
 
-        env.verifyNoAsyncErrors();
+        env.verifyNoAsyncErrorsNoDelay();
       }
     });
   }
@@ -307,7 +307,7 @@ public void run(WhiteboxTestStage stage) throws InterruptedException {
         stage.sendError(ex);
         stage.probe.expectError(ex);
 
-        env.verifyNoAsyncErrors();
+        env.verifyNoAsyncErrorsNoDelay();
       }
     });
   }
@@ -322,7 +322,7 @@ public void run(WhiteboxTestStage stage) throws InterruptedException {
         stage.sendError(ex);
         stage.probe.expectError(ex);
 
-        env.verifyNoAsyncErrors();
+        env.verifyNoAsyncErrorsNoDelay();
       }
     });
   }
@@ -358,10 +358,10 @@ public void run(WhiteboxTestStage stage) throws Throwable {
           sub.onSubscribe(null);
         } catch (final NullPointerException expected) {
           gotNPE = true;
-        }
-        assertTrue(gotNPE, "onSubscribe(null) did not throw NullPointerException");
+        } 
 
-        env.verifyNoAsyncErrors(env.defaultTimeoutMillis());
+        assertTrue(gotNPE, "onSubscribe(null) did not throw NullPointerException");
+        env.verifyNoAsyncErrorsNoDelay();
       }
     });
   }
@@ -379,11 +379,10 @@ public void run(WhiteboxTestStage stage) throws Throwable {
           sub.onNext(null);
         } catch (final NullPointerException expected) {
           gotNPE = true;
-        } finally {
-          assertTrue(gotNPE, "onNext(null) did not throw NullPointerException");
         }
 
-        env.verifyNoAsyncErrors(env.defaultTimeoutMillis());
+        assertTrue(gotNPE, "onNext(null) did not throw NullPointerException");
+        env.verifyNoAsyncErrorsNoDelay();
       }
     });
   }
@@ -405,7 +404,7 @@ public void run(WhiteboxTestStage stage) throws Throwable {
             assertTrue(gotNPE, "onError(null) did not throw NullPointerException");
           }
 
-        env.verifyNoAsyncErrors(env.defaultTimeoutMillis());
+        env.verifyNoAsyncErrorsNoDelay();
       }
     });
   }
@@ -566,7 +565,7 @@ public T nextT() throws InterruptedException {
     }
 
     public void verifyNoAsyncErrors() {
-      env.verifyNoAsyncErrors();
+      env.verifyNoAsyncErrorsNoDelay();
     }
   }
 
@@ -737,7 +736,7 @@ private SubscriberPuppet puppet() {
     public void registerOnSubscribe(SubscriberPuppet p) {
       if (!puppet.isCompleted()) {
         puppet.complete(p);
-      }
+      } 
     }
 
   }
diff --git a/tck/src/main/java/org/reactivestreams/tck/TestEnvironment.java b/tck/src/main/java/org/reactivestreams/tck/TestEnvironment.java
@@ -6,7 +6,6 @@
 import org.reactivestreams.tck.support.SubscriberBufferOverflowException;
 import org.reactivestreams.tck.support.Optional;
 
-import java.text.NumberFormat;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.concurrent.ArrayBlockingQueue;
@@ -107,7 +106,7 @@ public static long envDefaultTimeoutMillis() {
    * 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 {@code env.verifyNoAsyncErrors()} at the end of your TCK tests to verify there no flops called during it's execution.
+   * Use {@code 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 {@code expectError} methods or collect the error directly
    * from the environment using {@code env.dropAsyncError()}.
    *
@@ -127,7 +126,7 @@ public void flop(String msg) {
    *
    * This overload keeps the passed in throwable as the asyncError, instead of creating an AssertionError for this.
    *
-   * Use {@code env.verifyNoAsyncErrors()} at the end of your TCK tests to verify there no flops called during it's execution.
+   * Use {@code 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 {@code expectError} methods or collect the error directly
    * from the environment using {@code env.dropAsyncError()}.
    *
@@ -147,7 +146,7 @@ public void flop(Throwable thr, String msg) {
    *
    * This overload keeps the passed in throwable as the asyncError, instead of creating an AssertionError for this.
    *
-   * Use {@code env.verifyNoAsyncErrors()} at the end of your TCK tests to verify there no flops called during it's execution.
+   * Use {@code 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 {@code expectError} methods or collect the error directly
    * from the environment using {@code env.dropAsyncError()}.
    *
@@ -167,7 +166,7 @@ public void flop(Throwable thr) {
    * This method DOES fail the test right away (it tries to, by throwing an AssertionException),
    * in such it is different from {@link org.reactivestreams.tck.TestEnvironment#flop} which only records the error.
    *
-   * Use {@code env.verifyNoAsyncErrors()} at the end of your TCK tests to verify there no flops called during it's execution.
+   * Use {@code 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 {@code expectError} methods or collect the error directly
    * from the environment using {@code env.dropAsyncError()}.
    *
@@ -192,7 +191,7 @@ public <T> void subscribe(Publisher<T> pub, TestSubscriber<T> sub) throws Interr
   public <T> void subscribe(Publisher<T> pub, TestSubscriber<T> sub, long timeoutMillis) throws InterruptedException {
     pub.subscribe(sub);
     sub.subscription.expectCompletion(timeoutMillis, String.format("Could not subscribe %s to Publisher %s", sub, pub));
-    verifyNoAsyncErrors();
+    verifyNoAsyncErrorsNoDelay();
   }
 
   public <T> ManualSubscriber<T> newBlackholeSubscriber(Publisher<T> pub) throws InterruptedException {
@@ -223,16 +222,39 @@ public Throwable dropAsyncError() {
     }
   }
 
+  /**
+   * Waits for {@link TestEnvironment#defaultTimeoutMillis()} and then verifies that no asynchronous errors
+   * were signalled pior to, or during that time (by calling {@code flop()}).
+   */
+  public void verifyNoAsyncErrors() {
+    verifyNoAsyncErrors(defaultTimeoutMillis());
+  }
+
+  /**
+   * This version of {@code verifyNoAsyncErrors} should be used when errors still could be signalled
+   * asynchronously during {@link TestEnvironment#defaultTimeoutMillis()} time.
+   * <p></p>
+   * It will immediatly check if any async errors were signaled (using {@link TestEnvironment#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.
+   */
   public void verifyNoAsyncErrors(long delay) {
     try {
+      verifyNoAsyncErrorsNoDelay();
+
       Thread.sleep(delay);
-      verifyNoAsyncErrors();
+      verifyNoAsyncErrorsNoDelay();
     } catch (InterruptedException e) {
       throw new RuntimeException(e);
     }
   }
 
-  public void verifyNoAsyncErrors() {
+  /**
+   * Verifies that no asynchronous errors were signalled pior to calling this method (by calling {@code flop()}).
+   * This version of verifyNoAsyncError <b>does not wait before checking for asynchronous errors</b>, and is to be used
+   * for example in tight loops etc.
+   */
+  public void verifyNoAsyncErrorsNoDelay() {
     for (Throwable e : asyncErrors) {
       if (e instanceof AssertionError) {
         throw (AssertionError) e;
@@ -267,6 +289,9 @@ public Optional<StackTraceElement> findCallerMethodInStackTrace(String method) {
 
   // ---- classes ----
 
+  /**
+   * {@link Subscriber} implementation which can be steered by test code and asserted on.
+   */
   public static class ManualSubscriber<T> extends TestSubscriber<T> {
     Receptacle<T> received;
 

Original file line number	Diff line number	Diff line change
`@@ -460,9 +460,10 @@ public void run(Publisher<T> pub) throws Throwable {`
`460`	`460`	`try {`
`461`	`461`	`pub.subscribe(null);`
`462`	`462`	`env.flop("Publisher did not throw a NullPointerException when given a null Subscribe in subscribe");`
`463`		`- } catch (NullPointerException npe) {`
	`463`	`+ } catch (NullPointerException ignored) {`
	`464`	`+ // valid behaviour`
`464`	`465`	`}`
`465`		`- env.verifyNoAsyncErrors();`
	`466`	`+ env.verifyNoAsyncErrorsNoDelay();`
`466`	`467`	`}`
`467`	`468`	`});`
`468`	`469`	`}`
`@@ -497,7 +498,7 @@ public void onComplete() {`
`497`	`498`	`}`
`498`	`499`	`});`
`499`	`500`	`onSubscribeLatch.expectClose("Should have received onSubscribe");`
`500`		`- env.verifyNoAsyncErrors();`
	`501`	`+ env.verifyNoAsyncErrorsNoDelay();`
`501`	`502`	`}`
`502`	`503`	`});`
`503`	`504`	`}`
`@@ -528,7 +529,7 @@ public void onSubscribe(Subscription subs) {`
`528`	`529`	`onSubscribeLatch.expectClose("Should have received onSubscribe");`
`529`	`530`	`onErrorLatch.expectClose("Should have received onError");`
`530`	`531`
`531`		`- env.verifyNoAsyncErrors();`
	`532`	`+ env.verifyNoAsyncErrorsNoDelay();`
`532`	`533`	`}`
`533`	`534`	`});`
`534`	`535`	`}`
`@@ -777,7 +778,7 @@ public void onError(Throwable cause) {`
`777`	`778`	"awaited at-most %s signals (`maxOnNextSignalsInRecursionTest()`) or completion",
`778`	`779`	`oneMoreThanBoundedLimit);`
`779`	`780`	`runCompleted.expectClose(env.defaultTimeoutMillis(), msg);`
`780`		`- env.verifyNoAsyncErrors();`
	`781`	`+ env.verifyNoAsyncErrorsNoDelay();`
`781`	`782`	`} finally {`
`782`	`783`	`// since the request/onNext recursive calls may keep the publisher running "forever",`
`783`	`784`	`// we MUST cancel it manually before exiting this test case`
`@@ -828,7 +829,7 @@ public void cancel() {`
`828`	`829`	`sub.request(1);`
`829`	`830`
`830`	`831`	`sub.expectNone();`
`831`		`- env.verifyNoAsyncErrors();`
	`832`	`+ env.verifyNoAsyncErrorsNoDelay();`
`832`	`833`	`}`
`833`	`834`	`});`
`834`	`835`	`}`
`@@ -849,7 +850,7 @@ public void run(Publisher<T> pub) throws Throwable {`
`849`	`850`	`subs.cancel();`
`850`	`851`
`851`	`852`	`sub.expectNone();`
`852`		`- env.verifyNoAsyncErrors();`
	`853`	`+ env.verifyNoAsyncErrorsNoDelay();`
`853`	`854`	`}`
`854`	`855`	`});`
`855`	`856`	`}`
`@@ -940,7 +941,7 @@ > AsyncPublisher receives cancel() - handles it right away, by "stopping itself"`
`940`	`941`	`}`
`941`	`942`	`});`
`942`	`943`
`943`		`- env.verifyNoAsyncErrors();`
	`944`	`+ env.verifyNoAsyncErrorsNoDelay();`
`944`	`945`	`}`
`945`	`946`
`946`	`947`	`// Verifies rule: https://github.com/reactive-streams/reactive-streams#3.13`
`@@ -976,7 +977,7 @@ public void run(Publisher<T> pub) throws Throwable {`
`976`	`977`	`env.flop(String.format("Publisher %s did not drop reference to test subscriber after subscription cancellation", pub));`
`977`	`978`	`}`
`978`	`979`
`979`		`- env.verifyNoAsyncErrors();`
	`980`	`+ env.verifyNoAsyncErrorsNoDelay();`
`980`	`981`	`}`
`981`	`982`	`});`
`982`	`983`	`}`
`@@ -995,7 +996,7 @@ public void run(Publisher<T> pub) throws Throwable {`
`995`	`996`	`sub.nextElements(totalElements);`
`996`	`997`	`sub.expectCompletion();`
`997`	`998`
`998`		`- env.verifyNoAsyncErrors();`
	`999`	`+ env.verifyNoAsyncErrorsNoDelay();`
`999`	`1000`	`}`
`1000`	`1001`	`});`
`1001`	`1002`	`}`
`@@ -1017,7 +1018,7 @@ public void run(Publisher<T> pub) throws Throwable {`
`1017`	`1018`	`sub.expectCompletion();`
`1018`	`1019`
`1019`	`1020`	`try {`
`1020`		`- env.verifyNoAsyncErrors();`
	`1021`	`+ env.verifyNoAsyncErrorsNoDelay();`
`1021`	`1022`	`} finally {`
`1022`	`1023`	`sub.cancel();`
`1023`	`1024`	`}`
`@@ -1090,7 +1091,7 @@ public void activePublisherTest(long elements, boolean completionSignalRequired,`
`1090`	`1091`	`} else {`
`1091`	`1092`	`Publisher<T> pub = createPublisher(elements);`
`1092`	`1093`	`body.run(pub);`
`1093`		`- env.verifyNoAsyncErrors();`
	`1094`	`+ env.verifyNoAsyncErrorsNoDelay();`
`1094`	`1095`	`}`
`1095`	`1096`	`}`
`1096`	`1097`
Original file line number	Diff line number	Diff line change
`@@ -121,7 +121,7 @@ public void cancel() {`
`121`	`121`	`sub.onSubscribe(subs);`
`122`	`122`	`sub.onComplete();`
`123`	`123`
`124`		`- env.verifyNoAsyncErrors();`
	`124`	`+ env.verifyNoAsyncErrorsNoDelay();`
`125`	`125`	`}`
`126`	`126`	`});`
`127`	`127`	`}`
`@@ -160,7 +160,7 @@ public void cancel() {`
`160`	`160`	`sub.onSubscribe(subs);`
`161`	`161`	`sub.onError(new TestException());`
`162`	`162`
`163`		`- env.verifyNoAsyncErrors();`
	`163`	`+ env.verifyNoAsyncErrorsNoDelay();`
`164`	`164`	`}`
`165`	`165`	`});`
`166`	`166`	`}`
`@@ -196,7 +196,7 @@ public String toString() {`
`196`	`196`	`});`
`197`	`197`
`198`	`198`	secondSubscriptionCancelled.expectClose("Expected SecondSubscription given to subscriber to be cancelled, but `Subscription.cancel()` was not called.");
`199`		`- env.verifyNoAsyncErrors();`
	`199`	`+ env.verifyNoAsyncErrorsNoDelay();`
`200`	`200`	`}};`
`201`	`201`	`}`
`202`	`202`
`@@ -251,7 +251,7 @@ public void run(BlackboxTestStage stage) throws Throwable {`
`251`	`251`	`probe.expectCompletion();`
`252`	`252`	`probe.expectNone();`
`253`	`253`
`254`		`- env.verifyNoAsyncErrors();`
	`254`	`+ env.verifyNoAsyncErrorsNoDelay();`
`255`	`255`	`}`
`256`	`256`	`});`
`257`	`257`	`}`
`@@ -275,7 +275,7 @@ public void subscribe(Subscriber<? super T> s) {`
`275`	`275`	`pub.subscribe(probe);`
`276`	`276`	`probe.expectCompletion();`
`277`	`277`
`278`		`- env.verifyNoAsyncErrors();`
	`278`	`+ env.verifyNoAsyncErrorsNoDelay();`
`279`	`279`	`}`
`280`	`280`	`});`
`281`	`281`	`}`
`@@ -329,7 +329,7 @@ public void run(BlackboxTestStage stage) throws Throwable {`
`329`	`329`	`assertTrue(gotNPE, "onSubscribe(null) did not throw NullPointerException");`
`330`	`330`	`}`
`331`	`331`
`332`		`- env.verifyNoAsyncErrors();`
	`332`	`+ env.verifyNoAsyncErrorsNoDelay();`
`333`	`333`	`}`
`334`	`334`	`});`
`335`	`335`	`}`
`@@ -357,7 +357,7 @@ public void run(BlackboxTestStage stage) throws Throwable {`
`357`	`357`	`assertTrue(gotNPE, "onNext(null) did not throw NullPointerException");`
`358`	`358`	`}`
`359`	`359`
`360`		`- env.verifyNoAsyncErrors();`
	`360`	`+ env.verifyNoAsyncErrorsNoDelay();`
`361`	`361`	`}`
`362`	`362`	`});`
`363`	`363`	`}`
`@@ -385,7 +385,7 @@ public void run(BlackboxTestStage stage) throws Throwable {`
`385`	`385`	`assertTrue(gotNPE, "onError(null) did not throw NullPointerException");`
`386`	`386`	`}`
`387`	`387`
`388`		`- env.verifyNoAsyncErrors();`
	`388`	`+ env.verifyNoAsyncErrorsNoDelay();`
`389`	`389`	`}`
`390`	`390`	`});`
`391`	`391`	`}`
Original file line number	Diff line number	Diff line change
`@@ -149,7 +149,7 @@ public void cancel() {`
`149`	`149`	`sub.onSubscribe(subs);`
`150`	`150`	`sub.onComplete();`
`151`	`151`
`152`		`- env.verifyNoAsyncErrors();`
	`152`	`+ env.verifyNoAsyncErrorsNoDelay();`
`153`	`153`	`}`
`154`	`154`	`});`
`155`	`155`	`}`
`@@ -190,7 +190,7 @@ public void cancel() {`
`190`	`190`	`sub.onSubscribe(subs);`
`191`	`191`	`sub.onError(new TestException());`
`192`	`192`
`193`		`- env.verifyNoAsyncErrors();`
	`193`	`+ env.verifyNoAsyncErrorsNoDelay();`
`194`	`194`	`}`
`195`	`195`	`});`
`196`	`196`	`}`
`@@ -307,7 +307,7 @@ public void run(WhiteboxTestStage stage) throws InterruptedException {`
`307`	`307`	`stage.sendError(ex);`
`308`	`308`	`stage.probe.expectError(ex);`
`309`	`309`
`310`		`- env.verifyNoAsyncErrors();`
	`310`	`+ env.verifyNoAsyncErrorsNoDelay();`
`311`	`311`	`}`
`312`	`312`	`});`
`313`	`313`	`}`
`@@ -322,7 +322,7 @@ public void run(WhiteboxTestStage stage) throws InterruptedException {`
`322`	`322`	`stage.sendError(ex);`
`323`	`323`	`stage.probe.expectError(ex);`
`324`	`324`
`325`		`- env.verifyNoAsyncErrors();`
	`325`	`+ env.verifyNoAsyncErrorsNoDelay();`
`326`	`326`	`}`
`327`	`327`	`});`
`328`	`328`	`}`
`@@ -358,10 +358,10 @@ public void run(WhiteboxTestStage stage) throws Throwable {`
`358`	`358`	`sub.onSubscribe(null);`
`359`	`359`	`} catch (final NullPointerException expected) {`
`360`	`360`	`gotNPE = true;`
`361`		`- }`
`362`		`- assertTrue(gotNPE, "onSubscribe(null) did not throw NullPointerException");`
	`361`	`+ }`
`363`	`362`
`364`		`- env.verifyNoAsyncErrors(env.defaultTimeoutMillis());`
	`363`	`+ assertTrue(gotNPE, "onSubscribe(null) did not throw NullPointerException");`
	`364`	`+ env.verifyNoAsyncErrorsNoDelay();`
`365`	`365`	`}`
`366`	`366`	`});`
`367`	`367`	`}`
`@@ -379,11 +379,10 @@ public void run(WhiteboxTestStage stage) throws Throwable {`
`379`	`379`	`sub.onNext(null);`
`380`	`380`	`} catch (final NullPointerException expected) {`
`381`	`381`	`gotNPE = true;`
`382`		`- } finally {`
`383`		`- assertTrue(gotNPE, "onNext(null) did not throw NullPointerException");`
`384`	`382`	`}`
`385`	`383`
`386`		`- env.verifyNoAsyncErrors(env.defaultTimeoutMillis());`
	`384`	`+ assertTrue(gotNPE, "onNext(null) did not throw NullPointerException");`
	`385`	`+ env.verifyNoAsyncErrorsNoDelay();`
`387`	`386`	`}`
`388`	`387`	`});`
`389`	`388`	`}`
`@@ -405,7 +404,7 @@ public void run(WhiteboxTestStage stage) throws Throwable {`
`405`	`404`	`assertTrue(gotNPE, "onError(null) did not throw NullPointerException");`
`406`	`405`	`}`
`407`	`406`
`408`		`- env.verifyNoAsyncErrors(env.defaultTimeoutMillis());`
	`407`	`+ env.verifyNoAsyncErrorsNoDelay();`
`409`	`408`	`}`
`410`	`409`	`});`
`411`	`410`	`}`
`@@ -566,7 +565,7 @@ public T nextT() throws InterruptedException {`
`566`	`565`	`}`
`567`	`566`
`568`	`567`	`public void verifyNoAsyncErrors() {`
`569`		`- env.verifyNoAsyncErrors();`
	`568`	`+ env.verifyNoAsyncErrorsNoDelay();`
`570`	`569`	`}`
`571`	`570`	`}`
`572`	`571`
`@@ -737,7 +736,7 @@ private SubscriberPuppet puppet() {`
`737`	`736`	`public void registerOnSubscribe(SubscriberPuppet p) {`
`738`	`737`	`if (!puppet.isCompleted()) {`
`739`	`738`	`puppet.complete(p);`
`740`		`- }`
	`739`	`+ }`
`741`	`740`	`}`
`742`	`741`
`743`	`742`	`}`