public void testSuccessfulAsList_resultCancelledRacingInputDone() throws Exception { TestLogHandler listenerLoggerHandler = new TestLogHandler(); Logger exceptionLogger = Logger.getLogger(AbstractFuture.class.getName()); exceptionLogger.addHandler(listenerLoggerHandler); try { doTestSuccessfulAsList_resultCancelledRacingInputDone(); assertWithMessage("Nothing should be logged") .that(listenerLoggerHandler.getStoredLogRecords()) .isEmpty(); } finally { exceptionLogger.removeHandler(listenerLoggerHandler); } }
private static int getAndResetRecords(TestLogHandler logHandler) { int records = logHandler.getStoredLogRecords().size(); logHandler.clear(); return records; }
private void checkNothingLogged() { assertTrue(logHandler.getStoredLogRecords().isEmpty()); }
@Override public void setUp() throws Exception { super.setUp(); logHandler = new TestLogHandler(); LocalCache.logger.addHandler(logHandler); }
private void checkNothingLogged() { assertThat(logHandler.getStoredLogRecords()).isEmpty(); }
@Override public void setUp() throws Exception { super.setUp(); logHandler = new TestLogHandler(); LocalCache.logger.addHandler(logHandler); }
public void testEnqueueAndDispatch_withLabeledExceptions() { Object listener = new MyListener(); ListenerCallQueue<Object> queue = new ListenerCallQueue<>(); queue.addListener(listener, directExecutor()); queue.enqueue(THROWING_EVENT, "custom-label"); Logger logger = Logger.getLogger(ListenerCallQueue.class.getName()); logger.setLevel(Level.SEVERE); TestLogHandler logHandler = new TestLogHandler(); logger.addHandler(logHandler); try { queue.dispatch(); } finally { logger.removeHandler(logHandler); } assertEquals(1, logHandler.getStoredLogRecords().size()); assertEquals( "Exception while executing callback: MyListener custom-label", logHandler.getStoredLogRecords().get(0).getMessage()); }
public void test() throws Exception { assertTrue(handler.getStoredLogRecords().isEmpty()); ExampleClassUnderTest.foo(); LogRecord record = handler.getStoredLogRecords().get(0); assertEquals(Level.INFO, record.getLevel()); assertEquals("message", record.getMessage()); assertSame(EXCEPTION, record.getThrown()); }
private static int getAndResetRecords(TestLogHandler logHandler) { int records = logHandler.getStoredLogRecords().size(); logHandler.clear(); return records; }
@Override public void setUp() throws Exception { super.setUp(); logHandler = new TestLogHandler(); logger.addHandler(logHandler); }
public static void testLoggingSuppressor() throws IOException { TestLogHandler logHandler = new TestLogHandler(); Closeables.logger.addHandler(logHandler); try { Closer closer = new Closer(new Closer.LoggingSuppressor()); TestCloseable c1 = closer.register(TestCloseable.throwsOnClose(new IOException())); TestCloseable c2 = closer.register(TestCloseable.throwsOnClose(new RuntimeException())); try { throw closer.rethrow(new IOException("thrown"), IOException.class); } catch (IOException expected) { } assertTrue(logHandler.getStoredLogRecords().isEmpty()); closer.close(); assertEquals(2, logHandler.getStoredLogRecords().size()); LogRecord record = logHandler.getStoredLogRecords().get(0); assertEquals("Suppressing exception thrown when closing " + c2, record.getMessage()); record = logHandler.getStoredLogRecords().get(1); assertEquals("Suppressing exception thrown when closing " + c1, record.getMessage()); } finally { Closeables.logger.removeHandler(logHandler); } }
public void testConcurrentModification() throws Exception { // Tests for the absence of a bug where logging while iterating over the // stored log records causes a ConcurrentModificationException assertTrue(handler.getStoredLogRecords().isEmpty()); ExampleClassUnderTest.foo(); ExampleClassUnderTest.foo(); for (LogRecord unused : handler.getStoredLogRecords()) { ExampleClassUnderTest.foo(); } }
private Throwable popLoggedThrowable() { List<LogRecord> logRecords = logHandler.getStoredLogRecords(); assertSame(1, logRecords.size()); LogRecord logRecord = logRecords.get(0); logHandler.clear(); return logRecord.getThrown(); }
@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); } }); }
/** * Catches a bug where when constructing a service manager failed, later interactions with the * service could cause IllegalStateExceptions inside the partially constructed ServiceManager. * This ISE wouldn't actually bubble up but would get logged by ExecutionQueue. This obfuscated * the original error (which was not constructing ServiceManager correctly). */ public void testPartiallyConstructedManager() { Logger logger = Logger.getLogger("global"); logger.setLevel(Level.FINEST); TestLogHandler logHandler = new TestLogHandler(); logger.addHandler(logHandler); NoOpService service = new NoOpService(); service.startAsync(); try { new ServiceManager(Arrays.asList(service)); fail(); } catch (IllegalArgumentException expected) { } service.stopAsync(); // Nothing was logged! assertEquals(0, logHandler.getStoredLogRecords().size()); }
private void checkNothingLogged() { assertTrue(logHandler.getStoredLogRecords().isEmpty()); }
private Throwable popLoggedThrowable() { List<LogRecord> logRecords = logHandler.getStoredLogRecords(); assertEquals(1, logRecords.size()); LogRecord logRecord = logRecords.get(0); logHandler.clear(); return logRecord.getThrown(); }
@Override public void setUp() throws Exception { super.setUp(); logHandler = new TestLogHandler(); LocalCache.logger.addHandler(logHandler); }
Logger logger = Logger.getLogger(ServiceManager.class.getName()); logger.setLevel(Level.FINEST); TestLogHandler logHandler = new TestLogHandler(); logger.addHandler(logHandler); ServiceManager manager = new ServiceManager(Arrays.<Service>asList()); for (LogRecord record : logHandler.getStoredLogRecords()) { assertThat(logFormatter.format(record)).doesNotContain("NoOpService");
/** Ensure that errors are always logged. */ @SuppressWarnings("unchecked") public void testAllAsList_logging_error() throws Exception { try { getDone(allAsList(immediateFailedFuture(new MyError()))); fail(); } catch (ExecutionException expected) { assertThat(expected.getCause()).isInstanceOf(MyError.class); List<LogRecord> logged = aggregateFutureLogHandler.getStoredLogRecords(); assertThat(logged).hasSize(1); // errors are always logged assertThat(logged.get(0).getThrown()).isInstanceOf(MyError.class); } }