@Test(expected = NullPointerException.class) public void groupByValueNull() { just1.groupBy(new Function<Integer, Object>() { @Override public Object apply(Integer v) { return v; } }, null); }
public void groupByKeyNull() { just1.groupBy(new Function<Integer, Object>() { @Override public Object apply(Integer v) { return null; } }).blockingSubscribe(); }
@Test(expected = NullPointerException.class) public void groupByNull() { just1.groupBy(null); }
@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 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 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(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 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 @SuppressWarnings("unchecked") DefaultObserver<GroupedObservable<Boolean, Long>> o1 = mock(DefaultObserver.class); @SuppressWarnings("unchecked") DefaultObserver<GroupedObservable<Boolean, Long>> o2 = mock(DefaultObserver.class); // 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(); @SuppressWarnings("unchecked") DefaultObserver<Integer> o2 = mock(DefaultObserver.class); inner.get().subscribe(o2); verify(o2, never()).onComplete(); verify(o2, never()).onNext(anyInt()); verify(o2).onError(any(IllegalStateException.class)); }
@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 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 testGroupByUnsubscribe() { final Disposable s = mock(Disposable.class); Observable<Integer> o = Observable.unsafeCreate( new ObservableSource<Integer>() { @Override public void subscribe(Observer<? super Integer> observer) { observer.onSubscribe(s); } } ); TestObserver<Object> ts = new TestObserver<Object>(); o.groupBy(new Function<Integer, Integer>() { @Override public Integer apply(Integer integer) { return null; } }).subscribe(ts); ts.dispose(); verify(s).dispose(); }
@Test public void innerEscapeCompleted() { Observable<Integer> source = Observable.just(0); Observable<Integer> m = source.groupBy(identity, dbl).flatMap(FLATTEN_INTEGER); TestObserver<Object> ts = new TestObserver<Object>(); m.subscribe(ts); ts.awaitTerminalEvent(); ts.assertNoErrors(); System.out.println(ts.values()); }
@Test public void testTakeUnsubscribesOnGroupBy() throws Exception { Observable.merge( ObservableEventStream.getEventStream("HTTP-ClusterA", 50), ObservableEventStream.getEventStream("HTTP-ClusterB", 20) ) // group by type (2 clusters) .groupBy(new Function<Event, String>() { @Override public String apply(Event event) { return event.type; } }) .take(1) .blockingForEach(new Consumer<GroupedObservable<String, Event>>() { @Override public void accept(GroupedObservable<String, Event> v) { System.out.println(v); v.take(1).subscribe(); // FIXME groups need consumption to a certain degree to cancel upstream } }); System.out.println("**** finished"); Thread.sleep(200); // make sure the event streams receive their interrupt }
@Test public void delayErrorSimpleComplete() { Observable.just(1) .groupBy(Functions.justFunction(1), true) .flatMap(Functions.<Observable<Integer>>identity()) .test() .assertResult(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 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> ts = new TestObserver<Integer>(); m.subscribe(ts); ts.awaitTerminalEvent(); assertEquals(1, ts.errorCount()); ts.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> ts = new TestObserver<Integer>(); m.subscribe(ts); ts.awaitTerminalEvent(); assertEquals(1, ts.errorCount()); ts.assertNoValues(); }
@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); }
@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> ts = new TestObserver<Object>(); m.subscribe(ts); ts.awaitTerminalEvent(); assertEquals(1, ts.errorCount()); ts.assertValueCount(1); }