/** Creates a new {@link Closer}. */ public static Closer create() { return new Closer(SUPPRESSOR); }
/** Creates a new {@link Closer}. */ public static Closer create() { return new Closer(SUPPRESSOR); }
/** Creates a new {@link Closer}. */ public static Closer create() { return new Closer(SUPPRESSOR); }
public void testExceptionThrown_whileClosingLastCloseable() throws IOException { Closer closer = new Closer(suppressor); IOException exception = new IOException(); // c1 is added first, closed last TestCloseable c1 = closer.register(TestCloseable.throwsOnClose(exception)); TestCloseable c2 = closer.register(TestCloseable.normal()); try { closer.close(); } catch (Throwable expected) { assertSame(exception, expected); } assertTrue(c1.isClosed()); assertTrue(c2.isClosed()); assertTrue(suppressor.suppressions.isEmpty()); }
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 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 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 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) { assertThat(expected).isInstanceOf(IOException.class); } assertTrue(c1.isClosed()); assertTrue(c2.isClosed()); assertNull(c3); 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 { assertThat(getSuppressed(thrownException)).isEmpty(); 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 testCloseExceptionsSuppressed_whenExceptionThrownFromTryBlock() throws IOException { Closer closer = new Closer(suppressor); IOException tryException = new IOException(); IOException c1Exception = new IOException(); IOException c2Exception = new IOException(); 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 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 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()); }
private static void writeUtf8ToFile(File file, boolean append, String data) throws IOException { boolean skipBOM = append && file.isFile() && (file.length() > 0); Closer res = new Closer(); try { OutputStream out = res.using(new FileOutputStream(file, append)); Writer writer = res.using(new OutputStreamWriter(out, Charset .forName("UTF-8"))); if (!skipBOM) { writer.write('\uFEFF'); } writer.write(data); } finally { res.close(); } }
private static final Charset[] UTF_ENCODINGS = { Charset.forName("UTF-8"), Charset.forName("UTF-16LE"), Charset.forName("UTF-16BE") }; private static Charset getEncoding(InputStream in) throws IOException { charsetLoop: for (Charset encodings : UTF_ENCODINGS) { byte[] bom = "\uFEFF".getBytes(encodings); in.mark(bom.length); for (byte b : bom) { if ((0xFF & b) != in.read()) { in.reset(); continue charsetLoop; } } return encodings; } return Charset.defaultCharset(); } private static String readText(File file) throws IOException { Closer res = new Closer(); try { InputStream in = res.using(new FileInputStream(file)); InputStream bin = res.using(new BufferedInputStream(in)); Reader reader = res.using(new InputStreamReader(bin, getEncoding(bin))); StringBuilder out = new StringBuilder(); for (int ch = reader.read(); ch != -1; ch = reader.read()) out.append((char) ch); return out.toString(); } finally { res.close(); } }
/** * Creates a new {@link Closer}. */ public static Closer create() { return new Closer(SUPPRESSOR); }
/** * Creates a new {@link Closer}. */ public static Closer create() { return new Closer(SUPPRESSOR); }
/** * Creates a new {@link Closer}. */ public static Closer create() { return new Closer(SUPPRESSOR); }
/** * Creates a new {@link Closer}. */ public static Closer create() { return new Closer(SUPPRESSOR); }