@Override public Flowable<Object> apply(Flowable<Integer> f) throws Exception { return f.zipWith(Arrays.asList(1), new BiFunction<Integer, Integer, Object>() { @Override public Object apply(Integer a, Integer b) throws Exception { return a + b; } }); } });
@Test(expected = NullPointerException.class) public void zipWithIterableNull() { just1.zipWith((Iterable<Integer>)null, new BiFunction<Integer, Integer, Object>() { @Override public Object apply(Integer a, Integer b) { return 1; } }); }
@Test(expected = NullPointerException.class) public void zipWithPublisherNull() { just1.zipWith((Publisher<Integer>)null, new BiFunction<Integer, Integer, Object>() { @Override public Object apply(Integer a, Integer b) { return 1; } }); }
@Test(expected = NullPointerException.class) public void zipWithFlowableNull() { just1.zipWith((Flowable<Integer>)null, new BiFunction<Integer, Integer, Object>() { @Override public Object apply(Integer a, Integer b) { return 1; } }); }
@Override public Flowable<Object> apply(Flowable<? extends Throwable> attempt) { return attempt.zipWith(Flowable.just(1), new BiFunction<Throwable, Integer, Object>() { @Override public Object apply(Throwable o, Integer integer) { return 0; } }); } })
@Test(expected = NullPointerException.class) public void zipWithCombinerNull() { just1.zipWith(just1, null); }
@Test(expected = NullPointerException.class) public void zipWithIterableCombinerNull() { just1.zipWith(Arrays.asList(1), null); }
@Test(expected = NullPointerException.class) public void zipWithIterableCombinerReturnsNull() { just1.zipWith(Arrays.asList(1), new BiFunction<Integer, Integer, Object>() { @Override public Object apply(Integer a, Integer b) { return null; } }).blockingSubscribe(); }
@Test(expected = NullPointerException.class) public void zipWithCombinerReturnsNull() { just1.zipWith(just1, new BiFunction<Integer, Integer, Object>() { @Override public Object apply(Integer a, Integer b) { return null; } }).blockingSubscribe(); }
@Override public Publisher<Integer> createPublisher(long elements) { return Flowable.range(0, (int)elements) .zipWith(Flowable.range((int)elements, (int)elements), new BiFunction<Integer, Integer, Integer>() { @Override public Integer apply(Integer a, Integer b) throws Exception { return a + b; } }) ; } }
@Override public Publisher<Integer> createPublisher(long elements) { return Flowable.range(0, (int)elements) .zipWith(iterate(elements), new BiFunction<Integer, Long, Integer>() { @Override public Integer apply(Integer a, Long b) throws Exception { return a + b.intValue(); } }) ; } }
@Test public void dispose() { TestHelper.checkDisposed(Flowable.just(1).zipWith(Arrays.asList(1), new BiFunction<Integer, Integer, Object>() { @Override public Object apply(Integer a, Integer b) throws Exception { return a + b; } })); }
@Test(expected = NullPointerException.class) public void zipWithIterableIteratorNull() { just1.zipWith(new Iterable<Object>() { @Override public Iterator<Object> iterator() { return null; } }, new BiFunction<Integer, Object, Object>() { @Override public Object apply(Integer a, Object b) { return 1; } }).blockingSubscribe(); }
@Test(expected = NullPointerException.class) public void zipWithIterableOneIsNull() { Flowable.just(1, 2).zipWith(Arrays.asList(1, null), new BiFunction<Integer, Integer, Object>() { @Override public Object apply(Integer a, Integer b) { return 1; } }).blockingSubscribe(); }
@Test public void testTake2() { Flowable<Integer> f = Flowable.just(1, 2, 3, 4, 5); Iterable<String> it = Arrays.asList("a", "b", "c", "d", "e"); SquareStr squareStr = new SquareStr(); f.map(squareStr).zipWith(it, concat2Strings).take(2).subscribe(printer); assertEquals(2, squareStr.counter.get()); }
@Test public void iteratorThrows() { Flowable.just(1).zipWith(new CrashingIterable(100, 1, 100), new BiFunction<Integer, Integer, Object>() { @Override public Object apply(Integer a, Integer b) throws Exception { return a + b; } }) .test() .assertFailureAndMessage(TestException.class, "hasNext()"); }
@Test public void zipWithDelayError() { Flowable.just(1) .zipWith(Flowable.just(2), new BiFunction<Integer, Integer, Integer>() { @Override public Integer apply(Integer a, Integer b) throws Exception { return a + b; } }, true) .test() .assertResult(3); }
@Test public void zipWithDelayErrorBufferSize() { Flowable.just(1) .zipWith(Flowable.just(2), new BiFunction<Integer, Integer, Integer>() { @Override public Integer apply(Integer a, Integer b) throws Exception { return a + b; } }, true, 16) .test() .assertResult(3); } }
@Test public void testStartAsync() throws InterruptedException { Flowable<String> os = ASYNC_OBSERVABLE_OF_INFINITE_INTEGERS(new CountDownLatch(1)).onBackpressureBuffer() .zipWith(ASYNC_OBSERVABLE_OF_INFINITE_INTEGERS(new CountDownLatch(1)).onBackpressureBuffer(), new BiFunction<Integer, Integer, String>() { @Override public String apply(Integer a, Integer b) { return a + "-" + b; } }).take(5); TestSubscriber<String> ts = new TestSubscriber<String>(); os.subscribe(ts); ts.awaitTerminalEvent(); ts.assertNoErrors(); assertEquals(5, ts.valueCount()); assertEquals("1-1", ts.values().get(0)); assertEquals("2-2", ts.values().get(1)); assertEquals("5-5", ts.values().get(4)); }
@Test public void testUnboundedDownstreamOverrequesting() { Flowable<Integer> source = Flowable.range(1, 2).zipWith(Flowable.range(1, 2), new BiFunction<Integer, Integer, Integer>() { @Override public Integer apply(Integer t1, Integer t2) { return t1 + 10 * t2; } }); TestSubscriber<Integer> ts = new TestSubscriber<Integer>() { @Override public void onNext(Integer t) { super.onNext(t); request(5); } }; source.subscribe(ts); ts.assertNoErrors(); ts.assertTerminated(); ts.assertValues(11, 22); }