protected void stopProgressLoop() { progressUpdateReactor.set(null); }
@Test public void disposeState() { Disposable empty = Disposables.empty(); SerialDisposable d = new SerialDisposable(empty); assertFalse(d.isDisposed()); assertSame(empty, d.get()); d.dispose(); assertTrue(d.isDisposed()); assertNotSame(empty, d.get()); assertNotSame(DisposableHelper.DISPOSED, d.get()); } }
@Test public void getDisposableShouldReturnset() { final Disposable underlying = mock(Disposable.class); serialDisposable.set(underlying); assertSame(underlying, serialDisposable.get()); final Disposable another = mock(Disposable.class); serialDisposable.set(another); assertSame(another, serialDisposable.get()); }
final SerialDisposable sd = new SerialDisposable(); SingleObserver<String> ts = new SingleObserver<String>() { @Override public void subscribe(final SingleObserver<? super String> observer) { SerialDisposable sd = new SerialDisposable(); observer.onSubscribe(sd); final Thread t = new Thread(new Runnable() { sd.dispose();
ConditionalCompactorSubscriber(Subscriber<? super String> actual, long timeout, TimeUnit unit, Worker worker) { this.actual = actual; this.worker = worker; this.timeout = timeout; this.unit = unit; this.batch = new ArrayList<>(); this.wip = new AtomicInteger(); this.mas = new SerialDisposable(); this.mas.set(NO_TIMER); this.queue = new ConcurrentLinkedQueue<>(); }
@Override public void subscribe(final SingleObserver<? super String> observer) { SerialDisposable sd = new SerialDisposable(); observer.onSubscribe(sd); final Thread t = new Thread(new Runnable() { @Override public void run() { try { Thread.sleep(5000); observer.onSuccess("success"); } catch (InterruptedException e) { interrupted.set(true); latch.countDown(); } } }); sd.replace(Disposables.fromRunnable(new Runnable() { @Override public void run() { unsubscribed.set(true); t.interrupt(); latch.countDown(); } })); t.start(); } });
@Before public void setUp() { serialDisposable = new SerialDisposable(); }
@Override public void onConnectionUnsubscribed() { serialSubscription.dispose(); }
public boolean isProgressLoopRunning() { return progressUpdateReactor.get() != null; }
@Override public void onSubscribe(Disposable d) { sd.replace(d); }
int repeat = 0; for (;;) { final SerialDisposable task = new SerialDisposable(); try { final CountDownLatch finished = new CountDownLatch(1); task.dispose();
@Override public void subscribe(final SingleObserver<? super String> observer) { SerialDisposable sd = new SerialDisposable(); observer.onSubscribe(sd); final Thread t = new Thread(new Runnable() { @Override public void run() { try { Thread.sleep(5000); observer.onSuccess("success"); } catch (InterruptedException e) { interrupted.set(true); latch.countDown(); } } }); sd.replace(Disposables.fromRunnable(new Runnable() { @Override public void run() { unsubscribed.set(true); t.interrupt(); latch.countDown(); } })); t.start(); } });
@Override public void subscribe(final SingleObserver<? super String> observer) { SerialDisposable sd = new SerialDisposable(); observer.onSubscribe(sd); final Thread t = new Thread(new Runnable() {
@Override public void run() { try { start.await(); serialDisposable.dispose(); } catch (InterruptedException e) { fail(e.getMessage()); } finally { end.countDown(); } } };
@Override public void subscribe(final Subscriber<? super Integer> subscriber) { subscriber.onSubscribe(new BooleanSubscription()); task.replace(Schedulers.single().scheduleDirect(new Runnable() { @Override public void run() { try { while (running.get() && !task.isDisposed()) { subscriber.onNext(count.incrementAndGet()); timeHasPassed.countDown(); } subscriber.onComplete(); } catch (Throwable e) { subscriber.onError(e); } finally { finished.countDown(); } } })); }
@Override public void onConnectionSubscribed() { serialSubscription.set(mtuObservable.subscribe(this, new Consumer<Throwable>() { @Override public void accept(Throwable throwable) { // ignoring, this is expected when the connection is lost. } })); }