@Override public Flowable<String> apply(final GroupedFlowable<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; } }); }
@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 public void overrideNewThreadScheduler() { try { RxJavaCommonPlugins.setNewThreadSchedulerHandler(replaceWithImmediate); assertSame(ImmediateThinScheduler.INSTANCE, Schedulers.newThread()); } finally { RxJavaCommonPlugins.reset(); } // make sure the reset worked assertNotSame(ImmediateThinScheduler.INSTANCE, Schedulers.newThread()); }
@Test(timeout = 1500) public void timerNewThread() { Completable c = Completable.timer(500, TimeUnit.MILLISECONDS, Schedulers.newThread()); c.blockingAwait(); }
/** * Shuts down the standard Schedulers. * <p>The operation is idempotent and thread-safe. */ public static void shutdown() { computation().shutdown(); io().shutdown(); newThread().shutdown(); single().shutdown(); trampoline().shutdown(); SchedulerPoolFactory.shutdown(); }
/** * Starts the standard Schedulers. * <p>The operation is idempotent and thread-safe. */ public static void start() { computation().start(); io().start(); newThread().start(); single().start(); trampoline().start(); SchedulerPoolFactory.start(); }
/** * Starts the standard Schedulers. * <p>The operation is idempotent and thread-safe. */ public static void start() { computation().start(); io().start(); newThread().start(); single().start(); trampoline().start(); SchedulerPoolFactory.start(); }
/** * Shuts down the standard Schedulers. * <p>The operation is idempotent and thread-safe. */ public static void shutdown() { computation().shutdown(); io().shutdown(); newThread().shutdown(); single().shutdown(); trampoline().shutdown(); SchedulerPoolFactory.shutdown(); }
/** * Starts the standard Schedulers. * <p>The operation is idempotent and thread-safe. */ public static void start() { computation().start(); io().start(); newThread().start(); single().start(); trampoline().start(); SchedulerPoolFactory.start(); }
/** * Shuts down the standard Schedulers. * <p>The operation is idempotent and thread-safe. */ public static void shutdown() { computation().shutdown(); io().shutdown(); newThread().shutdown(); single().shutdown(); trampoline().shutdown(); SchedulerPoolFactory.shutdown(); }
@Test public void testDefaultNewThreadSchedulerIsInitializedLazily() { // unsafe default Scheduler Callable should not be evaluated try { RxJavaCommonPlugins.setInitNewThreadSchedulerHandler(initReplaceWithImmediate); RxJavaCommonPlugins.initNewThreadScheduler(unsafeDefault); } finally { RxJavaCommonPlugins.reset(); } // make sure the reset worked assertNotSame(ImmediateThinScheduler.INSTANCE, Schedulers.newThread()); }
@Test(timeout = 2000) public void testRepeatTake() { Flowable<Integer> xs = Flowable.just(1, 2); Object[] ys = xs.repeat().subscribeOn(Schedulers.newThread()).take(4).toList().blockingLast().toArray(); assertArrayEquals(new Object[] { 1, 2, 1, 2 }, ys); }
@Test(timeout = 2000) public void testRepeatTake() { Observable<Integer> xs = Observable.just(1, 2); Object[] ys = xs.repeat().subscribeOn(Schedulers.newThread()).take(4).toList().blockingGet().toArray(); assertArrayEquals(new Object[] { 1, 2, 1, 2 }, ys); }
@Test public void testAsynchronousRun() { Observable.range(1, 2).concatMapEager(new Function<Integer, Observable<Integer>>() { @Override public Observable<Integer> apply(Integer t) { return Observable.range(1, 1000).subscribeOn(Schedulers.computation()); } }).observeOn(Schedulers.newThread()).subscribe(ts); ts.awaitTerminalEvent(5, TimeUnit.SECONDS); ts.assertNoErrors(); ts.assertValueCount(2000); }
@Test public void testBackpressure1() { TestSubscriber<Integer> ts = new TestSubscriber<Integer>(); Flowable.range(1, 100000).takeLast(1) .observeOn(Schedulers.newThread()) .map(newSlowProcessor()).subscribe(ts); ts.awaitTerminalEvent(); ts.assertNoErrors(); ts.assertValue(100000); }
@Test public void testBackpressure1() { TestObserver<Integer> ts = new TestObserver<Integer>(); Observable.range(1, 100000).takeLast(1) .observeOn(Schedulers.newThread()) .map(newSlowProcessor()).subscribe(ts); ts.awaitTerminalEvent(); ts.assertNoErrors(); ts.assertValue(100000); }
@Test public void testBackpressure2() { TestObserver<Integer> ts = new TestObserver<Integer>(); Observable.range(1, 100000).takeLast(Observable.bufferSize() * 4) .observeOn(Schedulers.newThread()).map(newSlowProcessor()).subscribe(ts); ts.awaitTerminalEvent(); ts.assertNoErrors(); assertEquals(Observable.bufferSize() * 4, ts.valueCount()); }
@Test public void testBackpressure2() { TestSubscriber<Integer> ts = new TestSubscriber<Integer>(); Flowable.range(1, 100000).takeLast(Flowable.bufferSize() * 4) .observeOn(Schedulers.newThread()).map(newSlowProcessor()).subscribe(ts); ts.awaitTerminalEvent(); ts.assertNoErrors(); assertEquals(Flowable.bufferSize() * 4, ts.valueCount()); }