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 testErrors() throws IOException {
Closer closer = new Closer(suppressor);
Error c1Exception = new Error();
Error c2Exception = new Error();
Error c3Exception = new Error();
TestCloseable c1 = closer.register(TestCloseable.throwsOnClose(c1Exception));
TestCloseable c2 = closer.register(TestCloseable.throwsOnClose(c2Exception));
TestCloseable c3 = closer.register(TestCloseable.throwsOnClose(c3Exception));
try {
closer.close();
} catch (Throwable expected) {
assertSame(c3Exception, expected);
}
assertTrue(c1.isClosed());
assertTrue(c2.isClosed());
assertTrue(c3.isClosed());
assertSuppressed(
new Suppression(c2, c3Exception, c2Exception),
new Suppression(c1, c3Exception, c1Exception));
}
public void testCloseExceptionsSuppressed_whenExceptionThrownClosingFirstCloseable()
throws IOException {
Closer closer = new Closer(suppressor);
IOException c1Exception = new IOException();
IOException c2Exception = new IOException();
IOException c3Exception = new IOException();
TestCloseable c1 = closer.register(TestCloseable.throwsOnClose(c1Exception));
TestCloseable c2 = closer.register(TestCloseable.throwsOnClose(c2Exception));
TestCloseable c3 = closer.register(TestCloseable.throwsOnClose(c3Exception));
try {
closer.close();
} catch (Throwable expected) {
assertSame(c3Exception, expected);
}
assertTrue(c1.isClosed());
assertTrue(c2.isClosed());
assertTrue(c3.isClosed());
assertSuppressed(
new Suppression(c2, c3Exception, c2Exception),
new Suppression(c1, c3Exception, c1Exception));
}
public void testExceptionThrown_whenCreatingCloseables() throws IOException {
Closer closer = new Closer(suppressor);
TestCloseable c1 = null;
TestCloseable c2 = null;
TestCloseable c3 = null;
try {
try {
c1 = closer.register(TestCloseable.normal());
c2 = closer.register(TestCloseable.normal());
c3 = closer.register(TestCloseable.throwsOnCreate());
} catch (Throwable e) {
throw closer.rethrow(e);
} finally {
closer.close();
}
} catch (Throwable expected) {
assertTrue(expected instanceof IOException);
}
assertTrue(c1.isClosed());
assertTrue(c2.isClosed());
assertNull(c3);
assertTrue(suppressor.suppressions.isEmpty());
}
public void testExceptionThrown_fromTryBlock() throws IOException {
Closer closer = new Closer(suppressor);
TestCloseable c1 = closer.register(TestCloseable.normal());
TestCloseable c2 = closer.register(TestCloseable.normal());
IOException exception = new IOException();
try {
try {
throw exception;
} catch (Throwable e) {
throw closer.rethrow(e);
} finally {
closer.close();
}
} catch (Throwable expected) {
assertSame(exception, expected);
}
assertTrue(c1.isClosed());
assertTrue(c2.isClosed());
assertTrue(suppressor.suppressions.isEmpty());
}
public static void testSuppressingSuppressorIfPossible() throws IOException {
// can't test the JDK7 suppressor when not running on JDK7
if (!Closer.SuppressingSuppressor.isAvailable()) {
return;
}
Closer closer = new Closer(new Closer.SuppressingSuppressor());
IOException thrownException = new IOException();
IOException c1Exception = new IOException();
RuntimeException c2Exception = new RuntimeException();
TestCloseable c1 = closer.register(TestCloseable.throwsOnClose(c1Exception));
TestCloseable c2 = closer.register(TestCloseable.throwsOnClose(c2Exception));
try {
try {
throw thrownException;
} catch (Throwable e) {
throw closer.rethrow(thrownException, IOException.class);
} finally {
assertEquals(0, getSuppressed(thrownException).length);
closer.close();
}
} catch (IOException expected) {
assertSame(thrownException, expected);
}
assertTrue(c1.isClosed());
assertTrue(c2.isClosed());
ImmutableSet<Throwable> suppressed = ImmutableSet.copyOf(getSuppressed(thrownException));
assertEquals(2, suppressed.size());
assertEquals(ImmutableSet.of(c1Exception, c2Exception), suppressed);
}
public void testRuntimeExceptions() throws IOException {
Closer closer = new Closer(suppressor);
RuntimeException tryException = new RuntimeException();
RuntimeException c1Exception = new RuntimeException();
RuntimeException c2Exception = new RuntimeException();
TestCloseable c1 = closer.register(TestCloseable.throwsOnClose(c1Exception));
TestCloseable c2 = closer.register(TestCloseable.throwsOnClose(c2Exception));
try {
try {
throw tryException;
} catch (Throwable e) {
throw closer.rethrow(e);
} finally {
closer.close();
}
} catch (Throwable expected) {
assertSame(tryException, expected);
}
assertTrue(c1.isClosed());
assertTrue(c2.isClosed());
assertSuppressed(
new Suppression(c2, tryException, c2Exception),
new Suppression(c1, tryException, c1Exception));
}
public void testExceptionThrown_whileClosingFirstCloseable() throws IOException {
Closer closer = new Closer(suppressor);
IOException exception = new IOException();
// c2 is added last, closed first
TestCloseable c1 = closer.register(TestCloseable.normal());
TestCloseable c2 = closer.register(TestCloseable.throwsOnClose(exception));
try {
closer.close();
} catch (Throwable expected) {
assertSame(exception, expected);
}
assertTrue(c1.isClosed());
assertTrue(c2.isClosed());
assertTrue(suppressor.suppressions.isEmpty());
}
public void testNoExceptionsThrown() throws IOException {
Closer closer = new Closer(suppressor);
TestCloseable c1 = closer.register(TestCloseable.normal());
TestCloseable c2 = closer.register(TestCloseable.normal());
TestCloseable c3 = closer.register(TestCloseable.normal());
assertFalse(c1.isClosed());
assertFalse(c2.isClosed());
assertFalse(c3.isClosed());
closer.close();
assertTrue(c1.isClosed());
assertTrue(c2.isClosed());
assertTrue(c3.isClosed());
assertTrue(suppressor.suppressions.isEmpty());
}
