@Override public synchronized void dispose() { disposed = true; actual.dispose(); } }
@Override public synchronized void dispose() { disposed = true; actual.dispose(); } }
@Override public void onDisconnect() { renderer.dispose(); actions.goToStateInit(nextModelToStartFrom); }
@Override public void onDisconnect() { renderer.dispose(); actions.goToStateInit(nextModelToStartFrom); }
@Override public void dispose() { synchronized (modelObservers) { eventDispatcher.dispose(); effectDispatcher.dispose(); effectConsumer.dispose(); eventSourceDisposable.dispose(); modelObservers.clear(); disposed = true; } }
@Test public void delegatesDisposeToActualSink() throws Exception { safeConsumer = underTest.connect(recordingConsumer); safeConsumer.dispose(); assertThat(blockableConnection.disposed, is(true)); }
@Override public synchronized void dispose() { synchronized (modelObservers) { // Remove model observers so that they receive no further model changes. modelObservers.clear(); } // Disable the event and effect dispatchers. This will cause any further // events or effects posted to the dispatchers to be ignored and logged. eventDispatcher.disable(); effectDispatcher.disable(); // Stop the event source and effect handler. eventSourceDisposable.dispose(); effectConsumer.dispose(); // Finally clean up the dispatchers that now no longer are needed. eventDispatcher.dispose(); effectDispatcher.dispose(); disposed = true; }
@Test public void discardsEventsAfterDisposal() throws Exception { safeConsumer = underTest.connect(recordingConsumer); // given the effect performer is blocked blockableConnection.block = true; // when an effect is requested Future<?> effectPerformedFuture = executorService.submit( new Runnable() { @Override public void run() { safeConsumer.accept(1); } }); // and the sink is disposed safeConsumer.dispose(); // before the effect gets performed // (needs permitting the blocked effect performer to proceed) blockEffectPerformer.release(); // (get the result of the future to ensure the effect has been performed, also propagating // exceptions if any - result should happen quickly, but it's good to have a timeout in case // something is messed up) effectPerformedFuture.get(10, TimeUnit.SECONDS); // then no events are emitted recordingConsumer.assertValues(); }
@Test public void shouldPropagateDispose() throws Exception { mapped.connect(output).dispose(); assertThat(delegate.isDisposed(), is(true)); }
inOrder.verify(renderer).accept("init"); inOrder.verify(renderer).accept("init2"); inOrder.verify(renderer).dispose(); inOrder.verifyNoMoreInteractions();
@Test public void discardsEffectsAfterDisposal() throws Exception { // given a disposed sink safeConsumer = underTest.connect(recordingConsumer); safeConsumer.dispose(); // when an effect is performed safeConsumer.accept(1); // then no effects or events happen blockableConnection.assertEffects(); recordingConsumer.assertValues(); }