public void testSingleTearDown() throws Exception { final TearDownStack stack = buildTearDownStack(); final SimpleTearDown tearDown = new SimpleTearDown(); stack.addTearDown(tearDown); assertEquals(false, tearDown.ran); stack.runTearDown(); assertEquals("tearDown should have run", true, tearDown.ran); }
/** Builds a {@link TearDownStack} that makes sure it's clear by the end of this test. */ private TearDownStack buildTearDownStack() { final TearDownStack result = new TearDownStack(); tearDownStack.addTearDown( new TearDown() { @Override public void tearDown() throws Exception { synchronized (result.stack) { assertEquals( "The test should have cleared the stack (say, by virtue of running runTearDown)", 0, result.stack.size()); } } }); return result; }
@Override protected void tearDown() { tearDownStack.runTearDown(); }
FakeService() { tearDownStack.addTearDown(this); }
@Override protected void tearDown() { tearDownStack.runTearDown(); }
@Override protected void setUp() { // Clear any previous interrupt before running the test. if (Thread.currentThread().isInterrupted()) { throw new AssertionError( "Thread interrupted on test entry. " + "Some test probably didn't clear the interrupt state"); } tearDownStack.addTearDown( new TearDown() { @Override public void tearDown() { Thread.interrupted(); } }); }
public void testThrowingTearDown() throws Exception { final TearDownStack stack = buildTearDownStack(); final ThrowingTearDown tearDownOne = new ThrowingTearDown("one"); stack.addTearDown(tearDownOne); final ThrowingTearDown tearDownTwo = new ThrowingTearDown("two"); stack.addTearDown(tearDownTwo); assertEquals(false, tearDownOne.ran); assertEquals(false, tearDownTwo.ran); try { stack.runTearDown(); fail("runTearDown should have thrown an exception"); } catch (ClusterException expected) { assertThat(expected).hasCauseThat().hasMessageThat().isEqualTo("two"); } catch (RuntimeException e) { throw new RuntimeException( "A ClusterException should have been thrown, rather than a " + e.getClass().getName(), e); } assertEquals(true, tearDownOne.ran); assertEquals(true, tearDownTwo.ran); }
@Override protected void tearDown() { tearDownStack.runTearDown(); }
@Override protected void setUp() { final ExecutorService executor = Executors.newSingleThreadExecutor(); tearDownStack.addTearDown( new TearDown() { @Override public void tearDown() { executor.shutdownNow(); } }); sleeper = new SleepingRunnable(1000); delayedFuture = executor.submit(sleeper, true); tearDownStack.addTearDown( new TearDown() { @Override public void tearDown() { Thread.interrupted(); } }); }
/** * Builds a {@link TearDownStack} that makes sure it's clear by the end of * this test. */ private TearDownStack buildTearDownStack() { final TearDownStack result = new TearDownStack(); tearDownStack.addTearDown(new TearDown() { @Override public void tearDown() throws Exception { assertEquals( "The test should have cleared the stack (say, by virtue of running runTearDown)", 0, result.stack.size()); } }); return result; }
public void testMultipleTearDownsHappenInOrder() throws Exception { final TearDownStack stack = buildTearDownStack(); final SimpleTearDown tearDownOne = new SimpleTearDown(); stack.addTearDown(tearDownOne); final Callback callback = new Callback() { @Override public void run() { assertEquals( "tearDownTwo should have been run before tearDownOne", false, tearDownOne.ran); } }; final SimpleTearDown tearDownTwo = new SimpleTearDown(callback); stack.addTearDown(tearDownTwo); assertEquals(false, tearDownOne.ran); assertEquals(false, tearDownTwo.ran); stack.runTearDown(); assertEquals("tearDownOne should have run", true, tearDownOne.ran); assertEquals("tearDownTwo should have run", true, tearDownTwo.ran); }
@Override protected final void tearDown() { tearDownStack.runTearDown(); }
@Override protected void setUp() throws Exception { super.setUp(); handler = new TestLogHandler(); // You could also apply it higher up the Logger hierarchy than this ExampleClassUnderTest.logger.addHandler(handler); ExampleClassUnderTest.logger.setUseParentHandlers(false); // optional stack.addTearDown( new TearDown() { @Override public void tearDown() throws Exception { ExampleClassUnderTest.logger.setUseParentHandlers(true); ExampleClassUnderTest.logger.removeHandler(handler); } }); }
/** Builds a {@link TearDownStack} that makes sure it's clear by the end of this test. */ private TearDownStack buildTearDownStack() { final TearDownStack result = new TearDownStack(); tearDownStack.addTearDown( new TearDown() { @Override public void tearDown() throws Exception { synchronized (result.stack) { assertEquals( "The test should have cleared the stack (say, by virtue of running runTearDown)", 0, result.stack.size()); } } }); return result; }
public void testSingleTearDown() throws Exception { final TearDownStack stack = buildTearDownStack(); final SimpleTearDown tearDown = new SimpleTearDown(); stack.addTearDown(tearDown); assertEquals(false, tearDown.ran); stack.runTearDown(); assertEquals("tearDown should have run", true, tearDown.ran); }
@Override protected void tearDown() { stack.runTearDown(); }
@Override protected final void setUp() throws Exception { boolean fair = new Random().nextBoolean(); monitor = new Monitor(fair); tearDownStack.addTearDown(thread1 = new TestThread<>(monitor, "TestThread #1")); tearDownStack.addTearDown(thread2 = new TestThread<>(monitor, "TestThread #2")); }
public void testSingleTearDown() throws Exception { final TearDownStack stack = buildTearDownStack(); final SimpleTearDown tearDown = new SimpleTearDown(); stack.addTearDown(tearDown); assertEquals(false, tearDown.ran); stack.runTearDown(); assertEquals("tearDown should have run", true, tearDown.ran); }
@Override protected final void tearDown() { tearDownStack.runTearDown(); assertNull( "exceptions should not be propagated to uncaught exception handlers", thrownByExecutionThread); }
@Override public void addTearDown(TearDown tearDown) { tearDowns.addTearDown(tearDown); }