@Override public Observable<String> apply(Observable<Map<String, String>> o) { return o.map(new Function<Map<String, String>, String>() { @Override public String apply(Map<String, String> map) { return map.get("firstName"); } }); }
@Override public Observable<Integer> apply(final Integer leftValue, Observable<Integer> rightValues) { return rightValues.map(new Function<Integer, Integer>() { @Override public Integer apply(Integer rightValue) throws Exception { return add.apply(leftValue, rightValue); } }); }
@Override public ObservableSource<Object> apply(Integer v) throws Exception { return Observable.range(1, 2).map(new Function<Integer, Object>() { @Override public Object apply(Integer w) throws Exception { throw new TestException(); } }); } })
@Override public ObservableSource<Object> apply(Observable<Object> o) throws Exception { return o.map(Functions.identity()); } });
@Override public Object apply(Observable<Object> o) throws Exception { return o.map(Functions.identity()); } }, false, 1, 1, 1);
@Override public ObservableSource<Integer> apply(Integer v) throws Exception { return Observable.range(1, 2).map(new Function<Integer, Integer>() { @Override public Integer apply(Integer v) throws Exception { throw new TestException(); } }); } })
@Override public ObservableSource<Integer> apply(Integer v) throws Exception { return Observable.range(1, 2).map(new Function<Integer, Integer>() { @Override public Integer apply(Integer w) throws Exception { throw new TestException(); } }); } }, true)
private Observable<Integer> mergeNAsyncStreamsOfN(final int outerSize, final int innerSize) { Observable<Observable<Integer>> os = Observable.range(1, outerSize) .map(new Function<Integer, Observable<Integer>>() { @Override public Observable<Integer> apply(Integer i) { return Observable.range(1, innerSize).subscribeOn(Schedulers.computation()); } }); return Observable.merge(os); }
@Override public Observable<String> apply(final GroupedObservable<Integer, Integer> group) { return group.subscribeOn(Schedulers.newThread()).map(new Function<Integer, String>() { @Override public String apply(Integer t1) { System.out.println("Received: " + t1 + " on group : " + group.getKey()); return "first groups: " + t1; } }); }
@Test(expected = IllegalArgumentException.class) public void testMapWithIssue417() { Observable.just(1).observeOn(Schedulers.computation()) .map(new Function<Integer, Integer>() { @Override public Integer apply(Integer arg0) { throw new IllegalArgumentException("any error"); } }).blockingSingle(); }
private Observable<Integer> mergeNSyncStreamsOfN(final int outerSize, final int innerSize) { Observable<Observable<Integer>> os = Observable.range(1, outerSize) .map(new Function<Integer, Observable<Integer>>() { @Override public Observable<Integer> apply(Integer i) { return Observable.range(1, innerSize); } }); return Observable.merge(os); }
@Test(expected = NullPointerException.class) public void mapReturnsNull() { just1.map(new Function<Integer, Object>() { @Override public Object apply(Integer v) { return null; } }).blockingSubscribe(); }
@Test public void testTake2() { Observable<Integer> o = Observable.just(1, 2, 3, 4, 5); Iterable<String> it = Arrays.asList("a", "b", "c", "d", "e"); SquareStr squareStr = new SquareStr(); o.map(squareStr).zipWith(it, concat2Strings).take(2).subscribe(printer); assertEquals(2, squareStr.counter.get()); }
/** * We expect IllegalStateException to pass thru map. */ @Test(expected = IllegalStateException.class) public void testErrorPassesThruMap2() { Observable.error(new IllegalStateException()).map(new Function<Object, Object>() { @Override public Object apply(Object i) { return i; } }).blockingSingle(); }
@Override public Observable<String> apply(final String s) { return Observable.just(s) .mergeWith(Observable.interval(10, TimeUnit.MILLISECONDS) .map(new Function<Long, String>() { @Override public String apply(Long i) { return s + " " + i; } })).take(250); } })
@Ignore("Not sure what this does") @Test public void addOnNextValueExceptionAdded() throws Exception { Observer<BadToString> observer = new BadToStringObserver(); Observable.just(new BadToString(false)) .map(new Function<BadToString, BadToString>() { @Override public BadToString apply(BadToString badToString) { throw new IllegalArgumentException("Failure while handling"); } }).subscribe(observer); }
@Ignore("Not sure what this does") @Test public void addOnNextValueExceptionNotAddedWithBadString() throws Exception { Observer<BadToString> observer = new BadToStringObserver(); Observable.just(new BadToString(true)) .map(new Function<BadToString, BadToString>() { @Override public BadToString apply(BadToString badToString) { throw new IllegalArgumentException("Failure while handling"); } }).subscribe(observer); }
@Test(expected = IllegalArgumentException.class) public void testTakeWithError() { Observable.fromIterable(Arrays.asList(1, 2, 3)).take(1) .map(new Function<Integer, Integer>() { @Override public Integer apply(Integer t1) { throw new IllegalArgumentException("some error"); } }).blockingSingle(); }
@SuppressWarnings("unchecked") @Test public void source() { Observable<Integer> o = Observable.just(1); assertSame(o, ((HasUpstreamObservableSource<Integer>)o.map(Functions.<Integer>identity())).source()); } }
@Test public void fusedReject() { TestObserver<Integer> to = ObserverFusion.newTest(QueueFuseable.ANY | QueueFuseable.BOUNDARY); Observable.range(1, 5) .map(Functions.<Integer>identity()) .subscribe(to); ObserverFusion.assertFusion(to, QueueFuseable.NONE) .assertResult(1, 2, 3, 4, 5); }