public void groupByKeyNull() { just1.groupBy(new Function<Integer, Object>() { @Override public Object apply(Integer v) { return null; } }).blockingSubscribe(); }
@Test(expected = NullPointerException.class) public void groupByValueNull() { just1.groupBy(new Function<Integer, Object>() { @Override public Object apply(Integer v) { return v; } }, null); }
@Test(expected = NullPointerException.class) public void groupByNull() { just1.groupBy(null); }
@Test public void testGroupByWithElementSelector() { Observable<String> source = Observable.just("one", "two", "three", "four", "five", "six"); Observable<GroupedObservable<Integer, Integer>> grouped = source.groupBy(length, length); Map<Integer, Collection<Integer>> map = toMap(grouped); assertEquals(3, map.size()); assertArrayEquals(Arrays.asList(3, 3, 3).toArray(), map.get(3).toArray()); assertArrayEquals(Arrays.asList(4, 4).toArray(), map.get(4).toArray()); assertArrayEquals(Arrays.asList(5).toArray(), map.get(5).toArray()); }
@Test public void testGroupByWithElementSelector2() { Observable<String> source = Observable.just("one", "two", "three", "four", "five", "six"); Observable<GroupedObservable<Integer, Integer>> grouped = source.groupBy(length, length); Map<Integer, Collection<Integer>> map = toMap(grouped); assertEquals(3, map.size()); assertArrayEquals(Arrays.asList(3, 3, 3).toArray(), map.get(3).toArray()); assertArrayEquals(Arrays.asList(4, 4).toArray(), map.get(4).toArray()); assertArrayEquals(Arrays.asList(5).toArray(), map.get(5).toArray()); }
@Test public void testGroupByWithNullKey() { final String[] key = new String[]{"uninitialized"}; final List<String> values = new ArrayList<String>(); Observable.just("a", "b", "c").groupBy(new Function<String, String>() { @Override public String apply(String value) { return null; } }).subscribe(new Consumer<GroupedObservable<String, String>>() { @Override public void accept(GroupedObservable<String, String> groupedObservable) { key[0] = groupedObservable.getKey(); groupedObservable.subscribe(new Consumer<String>() { @Override public void accept(String s) { values.add(s); } }); } }); assertEquals(null, key[0]); assertEquals(Arrays.asList("a", "b", "c"), values); }
@Test public void testGroupBy() { Observable<String> source = Observable.just("one", "two", "three", "four", "five", "six"); Observable<GroupedObservable<Integer, String>> grouped = source.groupBy(length); Map<Integer, Collection<String>> map = toMap(grouped); assertEquals(3, map.size()); assertArrayEquals(Arrays.asList("one", "two", "six").toArray(), map.get(3).toArray()); assertArrayEquals(Arrays.asList("four", "five").toArray(), map.get(4).toArray()); assertArrayEquals(Arrays.asList("three").toArray(), map.get(5).toArray()); }
@Test(expected = NullPointerException.class) public void groupByValueReturnsNull() { just1.groupBy(new Function<Integer, Object>() { @Override public Object apply(Integer v) { return v; } }, new Function<Integer, Object>() { @Override public Object apply(Integer v) { return null; } }).blockingSubscribe(); }
@Test public void dispose() { TestHelper.checkDisposed(Observable.just(1).groupBy(Functions.justFunction(1))); Observable.just(1) .groupBy(Functions.justFunction(1)) .doOnNext(new Consumer<GroupedObservable<Integer, Integer>>() { @Override public void accept(GroupedObservable<Integer, Integer> g) throws Exception { TestHelper.checkDisposed(g); } }) .test(); }
@Test public void testGroupByOnAsynchronousSourceAcceptsMultipleSubscriptions() throws InterruptedException { // choose an asynchronous source Observable<Long> source = Observable.interval(10, TimeUnit.MILLISECONDS).take(1); // apply groupBy to the source Observable<GroupedObservable<Boolean, Long>> stream = source.groupBy(IS_EVEN); // create two observers Observer<GroupedObservable<Boolean, Long>> o1 = TestHelper.mockObserver(); Observer<GroupedObservable<Boolean, Long>> o2 = TestHelper.mockObserver(); // subscribe with the observers stream.subscribe(o1); stream.subscribe(o2); // check that subscriptions were successful verify(o1, never()).onError(Mockito.<Throwable> any()); verify(o2, never()).onError(Mockito.<Throwable> any()); }
/** * Assert we get an IllegalStateException if trying to subscribe to an inner GroupedObservable more than once. */ @Test public void testExceptionIfSubscribeToChildMoreThanOnce() { Observable<Integer> source = Observable.just(0); final AtomicReference<GroupedObservable<Integer, Integer>> inner = new AtomicReference<GroupedObservable<Integer, Integer>>(); Observable<GroupedObservable<Integer, Integer>> m = source.groupBy(identity, dbl); m.subscribe(new Consumer<GroupedObservable<Integer, Integer>>() { @Override public void accept(GroupedObservable<Integer, Integer> t1) { inner.set(t1); } }); inner.get().subscribe(); Observer<Integer> o2 = TestHelper.mockObserver(); inner.get().subscribe(o2); verify(o2, never()).onComplete(); verify(o2, never()).onNext(anyInt()); verify(o2).onError(any(IllegalStateException.class)); }
@Test public void testGroupByUnsubscribe() { final Disposable upstream = mock(Disposable.class); Observable<Integer> o = Observable.unsafeCreate( new ObservableSource<Integer>() { @Override public void subscribe(Observer<? super Integer> observer) { observer.onSubscribe(upstream); } } ); TestObserver<Object> to = new TestObserver<Object>(); o.groupBy(new Function<Integer, Integer>() { @Override public Integer apply(Integer integer) { return null; } }).subscribe(to); to.dispose(); verify(upstream).dispose(); }
@Test public void testEmpty() { Observable<String> source = Observable.empty(); Observable<GroupedObservable<Integer, String>> grouped = source.groupBy(length); Map<Integer, Collection<String>> map = toMap(grouped); assertTrue(map.isEmpty()); }
@Test public void innerEscapeCompleted() { Observable<Integer> source = Observable.just(0); Observable<Integer> m = source.groupBy(identity, dbl).flatMap(FLATTEN_INTEGER); TestObserver<Object> to = new TestObserver<Object>(); m.subscribe(to); to.awaitTerminalEvent(); to.assertNoErrors(); System.out.println(to.values()); }
@Test public void delayErrorSimpleComplete() { Observable.just(1) .groupBy(Functions.justFunction(1), true) .flatMap(Functions.<Observable<Integer>>identity()) .test() .assertResult(1); } }
@Test public void keySelectorThrows() { Observable<Integer> source = Observable.just(0, 1, 2, 3, 4, 5, 6); Observable<Integer> m = source.groupBy(fail(0), dbl).flatMap(FLATTEN_INTEGER); TestObserver<Integer> to = new TestObserver<Integer>(); m.subscribe(to); to.awaitTerminalEvent(); assertEquals(1, to.errorCount()); to.assertNoValues(); }
@Test public void valueSelectorThrows() { Observable<Integer> source = Observable.just(0, 1, 2, 3, 4, 5, 6); Observable<Integer> m = source.groupBy(identity, fail(0)).flatMap(FLATTEN_INTEGER); TestObserver<Integer> to = new TestObserver<Integer>(); m.subscribe(to); to.awaitTerminalEvent(); assertEquals(1, to.errorCount()); to.assertNoValues(); }
@Test public void testError2() { Observable<Integer> source = Observable.concat(Observable.just(0), Observable.<Integer> error(new TestException("Forced failure"))); Observable<Integer> m = source.groupBy(identity, dbl).flatMap(FLATTEN_INTEGER); TestObserver<Object> to = new TestObserver<Object>(); m.subscribe(to); to.awaitTerminalEvent(); assertEquals(1, to.errorCount()); to.assertValueCount(1); }
@Test public void keySelectorAndDelayError() { Observable.just(1).concatWith(Observable.<Integer>error(new TestException())) .groupBy(Functions.<Integer>identity(), true) .flatMap(new Function<GroupedObservable<Integer, Integer>, ObservableSource<Integer>>() { @Override public ObservableSource<Integer> apply(GroupedObservable<Integer, Integer> g) throws Exception { return g; } }) .test() .assertFailure(TestException.class, 1); }
@Test public void keyAndValueSelectorAndDelayError() { Observable.just(1).concatWith(Observable.<Integer>error(new TestException())) .groupBy(Functions.<Integer>identity(), Functions.<Integer>identity(), true) .flatMap(new Function<GroupedObservable<Integer, Integer>, ObservableSource<Integer>>() { @Override public ObservableSource<Integer> apply(GroupedObservable<Integer, Integer> g) throws Exception { return g; } }) .test() .assertFailure(TestException.class, 1); }