2.x: assertNever(T value) / assertNever(Predicate<T> valuePredicate) (#4994)

* 2.x: assertNever(T value) / assertNever(Predicate<T> valuePredicate)

* fixed Java compatibility issuesJ

* fixed Java type compatibility issues

* changes according to PR review

* changes according second PR review

Author: sergiomarqmoura

src/main/java/io/reactivex/observers/BaseTestConsumer.java

@@ -17,6 +17,7 @@
 import java.util.concurrent.*;
 
 import io.reactivex.Notification;
+import io.reactivex.annotations.Experimental;
 import io.reactivex.disposables.Disposable;
 import io.reactivex.exceptions.CompositeException;
 import io.reactivex.functions.Predicate;
@@ -303,6 +304,28 @@ public final U assertValue(T value) {
         return (U)this;
     }
 
+    /**
+     * Assert that this TestObserver/TestSubscriber did not receive an onNext value which is equal to
+     * the given value with respect to Objects.equals.
+     *
+     * @since 2.0.5 - experimental
+     * @param value the value to expect not being received
+     * @return this;
+     */
+    @Experimental
+    @SuppressWarnings("unchecked")
+    public final U assertNever(T value) {
+        int s = values.size();
+
+        for (int i = 0; i < s; i++) {
+            T v = this.values.get(i);
+            if (ObjectHelper.equals(v, value)) {
+                throw fail("Value at position " + i + " is equal to " + valueAndClass(value) + "; Expected them to be different");
+            }
+        }
+        return (U) this;
+    }
+
     /**
      * Asserts that this TestObserver/TestSubscriber received exactly one onNext value for which
      * the provided predicate returns true.
@@ -322,6 +345,33 @@ public final U assertValue(Predicate<T> valuePredicate) {
         return (U)this;
     }
 
+    /**
+     * Asserts that this TestObserver/TestSubscriber did not receive any onNext value for which
+     * the provided predicate returns true.
+     *
+     * @since 2.0.5 - experimental
+     * @param valuePredicate the predicate that receives the onNext value
+     *                       and should return true for the expected value.
+     * @return this
+     */
+    @Experimental
+    @SuppressWarnings("unchecked")
+    public final U assertNever(Predicate<? super T> valuePredicate) {
+        int s = values.size();
+
+        for (int i = 0; i < s; i++) {
+            T v = this.values.get(i);
+            try {
+                if (valuePredicate.test(v)) {
+                    throw fail("Value at position " + i + " matches predicate " + valuePredicate.toString() + ", which was not expected.");
+                }
+            } catch (Exception ex) {
+                throw ExceptionHelper.wrapOrThrow(ex);
+            }
+        }
+        return (U)this;
+    }
+
     /**
      * Asserts that this TestObserver/TestSubscriber received an onNext value at the given index
      * for the provided predicate returns true.

src/test/java/io/reactivex/observers/TestObserverTest.java

@@ -86,6 +86,64 @@ public void testAssertNotMatchValue() {
         o.assertTerminated();
     }
 
+    @Test
+    public void assertNeverAtNotMatchingValue() {
+        Flowable<Integer> oi = Flowable.fromIterable(Arrays.asList(1, 2));
+        TestSubscriber<Integer> o = new TestSubscriber<Integer>();
+        oi.subscribe(o);
+
+        o.assertNever(3);
+        o.assertValueCount(2);
+        o.assertTerminated();
+    }
+
+    @Test
+    public void assertNeverAtMatchingValue() {
+        Flowable<Integer> oi = Flowable.fromIterable(Arrays.asList(1, 2));
+        TestSubscriber<Integer> o = new TestSubscriber<Integer>();
+        oi.subscribe(o);
+
+        o.assertValues(1, 2);
+
+        thrown.expect(AssertionError.class);
+
+        o.assertNever(2);
+        o.assertValueCount(2);
+        o.assertTerminated();
+    }
+
+    @Test
+    public void assertNeverAtMatchingPredicate() {
+        TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
+
+        Flowable.just(1, 2).subscribe(ts);
+
+        ts.assertValues(1, 2);
+
+        thrown.expect(AssertionError.class);
+
+        ts.assertNever(new Predicate<Integer>() {
+            @Override
+            public boolean test(final Integer o) throws Exception {
+                return o == 1;
+            }
+        });
+    }
+
+    @Test
+    public void assertNeverAtNotMatchingPredicate() {
+        TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
+
+        Flowable.just(2, 3).subscribe(ts);
+
+        ts.assertNever(new Predicate<Integer>() {
+            @Override
+            public boolean test(final Integer o) throws Exception {
+                return o == 1;
+            }
+        });
+    }
+
     @Test
     public void testAssertTerminalEventNotReceived() {
         PublishProcessor<Integer> p = PublishProcessor.create();

src/test/java/io/reactivex/subscribers/TestSubscriberTest.java

@@ -83,6 +83,64 @@ public void testAssertNotMatchValue() {
         o.assertTerminated();
     }
 
+    @Test
+    public void assertNeverAtNotMatchingValue() {
+        Flowable<Integer> oi = Flowable.fromIterable(Arrays.asList(1, 2));
+        TestSubscriber<Integer> o = new TestSubscriber<Integer>();
+        oi.subscribe(o);
+
+        o.assertNever(3);
+        o.assertValueCount(2);
+        o.assertTerminated();
+    }
+
+    @Test
+    public void assertNeverAtMatchingValue() {
+        Flowable<Integer> oi = Flowable.fromIterable(Arrays.asList(1, 2));
+        TestSubscriber<Integer> o = new TestSubscriber<Integer>();
+        oi.subscribe(o);
+
+        o.assertValues(1, 2);
+
+        thrown.expect(AssertionError.class);
+
+        o.assertNever(2);
+        o.assertValueCount(2);
+        o.assertTerminated();
+    }
+
+    @Test
+    public void assertNeverAtMatchingPredicate() {
+        TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
+
+        Flowable.just(1, 2).subscribe(ts);
+
+        ts.assertValues(1, 2);
+
+        thrown.expect(AssertionError.class);
+
+        ts.assertNever(new Predicate<Integer>() {
+            @Override
+            public boolean test(final Integer o) throws Exception {
+                return o == 1;
+            }
+        });
+    }
+
+    @Test
+    public void assertNeverAtNotMatchingPredicate() {
+        TestSubscriber<Integer> ts = new TestSubscriber<Integer>();
+
+        Flowable.just(2, 3).subscribe(ts);
+
+        ts.assertNever(new Predicate<Integer>() {
+            @Override
+            public boolean test(final Integer o) throws Exception {
+                return o == 1;
+            }
+        });
+    }
+
     @Test
     public void testAssertTerminalEventNotReceived() {
         PublishProcessor<Integer> p = PublishProcessor.create();