+TCK verifyNoAsyncErrors now by default waits, fixes spec111

ktoso · ktoso · commit 9453fd3a25b8 · 2015-03-10T12:46:31.000-07: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
@@ -404,7 +404,7 @@ public TestSetup apply(Long aLong) throws Throwable {
           sub1.expectError(ex);
           sub2.expectError(ex);
 
-          env.verifyNoAsyncErrors();
+          env.verifyNoAsyncErrorsNoDelay();
         }};
       }
     });
@@ -476,7 +476,7 @@ public void mustImmediatelyPassOnOnErrorEventsReceivedFromItsUpstreamToItsDownst
       sendError(ex);
       sub.expectError(ex); // "immediately", i.e. without a preceding request
 
-      env.verifyNoAsyncErrors();
+      env.verifyNoAsyncErrorsNoDelay();
     }};
   }
 
@@ -664,7 +664,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
@@ -456,9 +456,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();
       }
     });
   }
@@ -493,7 +494,7 @@ public void onComplete() {
           }
         });
         onSubscribeLatch.expectClose("Should have received onSubscribe");
-        env.verifyNoAsyncErrors();
+        env.verifyNoAsyncErrorsNoDelay();
       }
     });
   }
@@ -524,7 +525,7 @@ public void onSubscribe(Subscription subs) {
         onSubscribeLatch.expectClose("Should have received onSubscribe");
         onErrorLatch.expectClose("Should have received onError");
 
-        env.verifyNoAsyncErrors();
+        env.verifyNoAsyncErrorsNoDelay();
       }
     });
   }
@@ -773,7 +774,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
@@ -824,7 +825,7 @@ public void cancel() {
         sub.request(1);
 
         sub.expectNone();
-        env.verifyNoAsyncErrors();
+        env.verifyNoAsyncErrorsNoDelay();
       }
     });
   }
@@ -845,7 +846,7 @@ public void run(Publisher<T> pub) throws Throwable {
         subs.cancel();
 
         sub.expectNone();
-        env.verifyNoAsyncErrors();
+        env.verifyNoAsyncErrorsNoDelay();
       }
     });
   }
@@ -936,7 +937,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
@@ -972,7 +973,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();
       }
     });
   }
@@ -991,7 +992,7 @@ public void run(Publisher<T> pub) throws Throwable {
         sub.nextElements(totalElements);
         sub.expectCompletion();
 
-        env.verifyNoAsyncErrors();
+        env.verifyNoAsyncErrorsNoDelay();
       }
     });
   }
@@ -1013,7 +1014,7 @@ public void run(Publisher<T> pub) throws Throwable {
         sub.expectCompletion();
 
         try {
-          env.verifyNoAsyncErrors();
+          env.verifyNoAsyncErrorsNoDelay();
         } finally {
           sub.cancel();
         }
@@ -1086,7 +1087,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();
       }
     });
   }
@@ -226,7 +226,7 @@ public String toString() {
           });
 
       secondSubscriptionCancelled.expectClose("Expected 2nd Subscription given to subscriber to be cancelled, but `Subscription.cancel()` was not called.");
-      env.verifyNoAsyncErrors();
+      env.verifyNoAsyncErrorsNoDelay();
     }};
   }
 
@@ -303,7 +303,7 @@ public void run(WhiteboxTestStage stage) throws InterruptedException {
         stage.sendError(ex);
         stage.probe.expectError(ex);
 
-        env.verifyNoAsyncErrors();
+        env.verifyNoAsyncErrorsNoDelay();
       }
     });
   }
@@ -318,7 +318,7 @@ public void run(WhiteboxTestStage stage) throws InterruptedException {
         stage.sendError(ex);
         stage.probe.expectError(ex);
 
-        env.verifyNoAsyncErrors();
+        env.verifyNoAsyncErrorsNoDelay();
       }
     });
   }
@@ -359,7 +359,7 @@ public void run(WhiteboxTestStage stage) throws Throwable {
           assertTrue(gotNPE, "onSubscribe(null) did not throw NullPointerException");
         }
 
-        env.verifyNoAsyncErrors();
+        env.verifyNoAsyncErrorsNoDelay();
       }
     });
   }// Verifies rule: https://github.com/reactive-streams/reactive-streams#2.13
@@ -391,7 +391,7 @@ public void cancel() {
           assertTrue(gotNPE, "onNext(null) did not throw NullPointerException");
         }
 
-        env.verifyNoAsyncErrors();
+        env.verifyNoAsyncErrorsNoDelay();
       }
     });
   }
@@ -425,7 +425,7 @@ public void cancel() {
           assertTrue(gotNPE, "onError(null) did not throw NullPointerException");
         }
 
-        env.verifyNoAsyncErrors();
+        env.verifyNoAsyncErrorsNoDelay();
       }
     });
   }
@@ -570,7 +570,7 @@ public T nextT() throws InterruptedException {
     }
 
     public void verifyNoAsyncErrors() {
-      env.verifyNoAsyncErrors();
+      env.verifyNoAsyncErrorsNoDelay();
     }
   }
 
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,44 @@ 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() {
+    try {
+      Thread.sleep(defaultTimeoutMillis());
+      verifyNoAsyncErrorsNoDelay();
+    } catch (InterruptedException e) {
+      throw new RuntimeException(e);
+    }
+  }
+
+  /**
+   * 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 +294,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
`@@ -456,9 +456,10 @@ public void run(Publisher<T> pub) throws Throwable {`
`456`	`456`	`try {`
`457`	`457`	`pub.subscribe(null);`
`458`	`458`	`env.flop("Publisher did not throw a NullPointerException when given a null Subscribe in subscribe");`
`459`		`- } catch (NullPointerException npe) {`
	`459`	`+ } catch (NullPointerException ignored) {`
	`460`	`+ // valid behaviour`
`460`	`461`	`}`
`461`		`- env.verifyNoAsyncErrors();`
	`462`	`+ env.verifyNoAsyncErrorsNoDelay();`
`462`	`463`	`}`
`463`	`464`	`});`
`464`	`465`	`}`
`@@ -493,7 +494,7 @@ public void onComplete() {`
`493`	`494`	`}`
`494`	`495`	`});`
`495`	`496`	`onSubscribeLatch.expectClose("Should have received onSubscribe");`
`496`		`- env.verifyNoAsyncErrors();`
	`497`	`+ env.verifyNoAsyncErrorsNoDelay();`
`497`	`498`	`}`
`498`	`499`	`});`
`499`	`500`	`}`
`@@ -524,7 +525,7 @@ public void onSubscribe(Subscription subs) {`
`524`	`525`	`onSubscribeLatch.expectClose("Should have received onSubscribe");`
`525`	`526`	`onErrorLatch.expectClose("Should have received onError");`
`526`	`527`
`527`		`- env.verifyNoAsyncErrors();`
	`528`	`+ env.verifyNoAsyncErrorsNoDelay();`
`528`	`529`	`}`
`529`	`530`	`});`
`530`	`531`	`}`
`@@ -773,7 +774,7 @@ public void onError(Throwable cause) {`
`773`	`774`	"awaited at-most %s signals (`maxOnNextSignalsInRecursionTest()`) or completion",
`774`	`775`	`oneMoreThanBoundedLimit);`
`775`	`776`	`runCompleted.expectClose(env.defaultTimeoutMillis(), msg);`
`776`		`- env.verifyNoAsyncErrors();`
	`777`	`+ env.verifyNoAsyncErrorsNoDelay();`
`777`	`778`	`} finally {`
`778`	`779`	`// since the request/onNext recursive calls may keep the publisher running "forever",`
`779`	`780`	`// we MUST cancel it manually before exiting this test case`
`@@ -824,7 +825,7 @@ public void cancel() {`
`824`	`825`	`sub.request(1);`
`825`	`826`
`826`	`827`	`sub.expectNone();`
`827`		`- env.verifyNoAsyncErrors();`
	`828`	`+ env.verifyNoAsyncErrorsNoDelay();`
`828`	`829`	`}`
`829`	`830`	`});`
`830`	`831`	`}`
`@@ -845,7 +846,7 @@ public void run(Publisher<T> pub) throws Throwable {`
`845`	`846`	`subs.cancel();`
`846`	`847`
`847`	`848`	`sub.expectNone();`
`848`		`- env.verifyNoAsyncErrors();`
	`849`	`+ env.verifyNoAsyncErrorsNoDelay();`
`849`	`850`	`}`
`850`	`851`	`});`
`851`	`852`	`}`
`@@ -936,7 +937,7 @@ > AsyncPublisher receives cancel() - handles it right away, by "stopping itself"`
`936`	`937`	`}`
`937`	`938`	`});`
`938`	`939`
`939`		`- env.verifyNoAsyncErrors();`
	`940`	`+ env.verifyNoAsyncErrorsNoDelay();`
`940`	`941`	`}`
`941`	`942`
`942`	`943`	`// Verifies rule: https://github.com/reactive-streams/reactive-streams#3.13`
`@@ -972,7 +973,7 @@ public void run(Publisher<T> pub) throws Throwable {`
`972`	`973`	`env.flop(String.format("Publisher %s did not drop reference to test subscriber after subscription cancellation", pub));`
`973`	`974`	`}`
`974`	`975`
`975`		`- env.verifyNoAsyncErrors();`
	`976`	`+ env.verifyNoAsyncErrorsNoDelay();`
`976`	`977`	`}`
`977`	`978`	`});`
`978`	`979`	`}`
`@@ -991,7 +992,7 @@ public void run(Publisher<T> pub) throws Throwable {`
`991`	`992`	`sub.nextElements(totalElements);`
`992`	`993`	`sub.expectCompletion();`
`993`	`994`
`994`		`- env.verifyNoAsyncErrors();`
	`995`	`+ env.verifyNoAsyncErrorsNoDelay();`
`995`	`996`	`}`
`996`	`997`	`});`
`997`	`998`	`}`
`@@ -1013,7 +1014,7 @@ public void run(Publisher<T> pub) throws Throwable {`
`1013`	`1014`	`sub.expectCompletion();`
`1014`	`1015`
`1015`	`1016`	`try {`
`1016`		`- env.verifyNoAsyncErrors();`
	`1017`	`+ env.verifyNoAsyncErrorsNoDelay();`
`1017`	`1018`	`} finally {`
`1018`	`1019`	`sub.cancel();`
`1019`	`1020`	`}`
`@@ -1086,7 +1087,7 @@ public void activePublisherTest(long elements, boolean completionSignalRequired,`
`1086`	`1087`	`} else {`
`1087`	`1088`	`Publisher<T> pub = createPublisher(elements);`
`1088`	`1089`	`body.run(pub);`
`1089`		`- env.verifyNoAsyncErrors();`
	`1090`	`+ env.verifyNoAsyncErrorsNoDelay();`
`1090`	`1091`	`}`
`1091`	`1092`	`}`
`1092`	`1093`
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`	`}`
`@@ -226,7 +226,7 @@ public String toString() {`
`226`	`226`	`});`
`227`	`227`
`228`	`228`	secondSubscriptionCancelled.expectClose("Expected 2nd Subscription given to subscriber to be cancelled, but `Subscription.cancel()` was not called.");
`229`		`- env.verifyNoAsyncErrors();`
	`229`	`+ env.verifyNoAsyncErrorsNoDelay();`
`230`	`230`	`}};`
`231`	`231`	`}`
`232`	`232`
`@@ -303,7 +303,7 @@ public void run(WhiteboxTestStage stage) throws InterruptedException {`
`303`	`303`	`stage.sendError(ex);`
`304`	`304`	`stage.probe.expectError(ex);`
`305`	`305`
`306`		`- env.verifyNoAsyncErrors();`
	`306`	`+ env.verifyNoAsyncErrorsNoDelay();`
`307`	`307`	`}`
`308`	`308`	`});`
`309`	`309`	`}`
`@@ -318,7 +318,7 @@ public void run(WhiteboxTestStage stage) throws InterruptedException {`
`318`	`318`	`stage.sendError(ex);`
`319`	`319`	`stage.probe.expectError(ex);`
`320`	`320`
`321`		`- env.verifyNoAsyncErrors();`
	`321`	`+ env.verifyNoAsyncErrorsNoDelay();`
`322`	`322`	`}`
`323`	`323`	`});`
`324`	`324`	`}`
`@@ -359,7 +359,7 @@ public void run(WhiteboxTestStage stage) throws Throwable {`
`359`	`359`	`assertTrue(gotNPE, "onSubscribe(null) did not throw NullPointerException");`
`360`	`360`	`}`
`361`	`361`
`362`		`- env.verifyNoAsyncErrors();`
	`362`	`+ env.verifyNoAsyncErrorsNoDelay();`
`363`	`363`	`}`
`364`	`364`	`});`
`365`	`365`	`}// Verifies rule: https://github.com/reactive-streams/reactive-streams#2.13`
`@@ -391,7 +391,7 @@ public void cancel() {`
`391`	`391`	`assertTrue(gotNPE, "onNext(null) did not throw NullPointerException");`
`392`	`392`	`}`
`393`	`393`
`394`		`- env.verifyNoAsyncErrors();`
	`394`	`+ env.verifyNoAsyncErrorsNoDelay();`
`395`	`395`	`}`
`396`	`396`	`});`
`397`	`397`	`}`
`@@ -425,7 +425,7 @@ public void cancel() {`
`425`	`425`	`assertTrue(gotNPE, "onError(null) did not throw NullPointerException");`
`426`	`426`	`}`
`427`	`427`
`428`		`- env.verifyNoAsyncErrors();`
	`428`	`+ env.verifyNoAsyncErrorsNoDelay();`
`429`	`429`	`}`
`430`	`430`	`});`
`431`	`431`	`}`
`@@ -570,7 +570,7 @@ public T nextT() throws InterruptedException {`
`570`	`570`	`}`
`571`	`571`
`572`	`572`	`public void verifyNoAsyncErrors() {`
`573`		`- env.verifyNoAsyncErrors();`
	`573`	`+ env.verifyNoAsyncErrorsNoDelay();`
`574`	`574`	`}`
`575`	`575`	`}`
`576`	`576`