android/guava-tests/test/com/google/common/io/CloserTest.java - platform/external/guava - Git at Google

 /*
  * Copyright (C) 2012 The Guava Authors
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  * http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package com.google.common.io;

 import static com.google.common.truth.Truth.assertThat;

 import com.google.common.base.MoreObjects;
 import com.google.common.base.Objects;
 import com.google.common.base.Throwables;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.Lists;
 import com.google.common.testing.TestLogHandler;
 import java.io.Closeable;
 import java.io.IOException;
 import java.lang.reflect.Method;
 import java.util.List;
 import java.util.logging.LogRecord;
 import junit.framework.TestCase;
 import org.checkerframework.checker.nullness.compatqual.NullableDecl;

 /**
  * Tests for {@link Closer}.
  *
  * @author Colin Decker
  */
 public class CloserTest extends TestCase {

   private TestSuppressor suppressor;

   @Override
   protected void setUp() throws Exception {
     suppressor = new TestSuppressor();
   }

   @AndroidIncompatible // TODO(cpovirk): Look up Build.VERSION.SDK_INT reflectively.
   public void testCreate() {
     assertThat(Closer.create().suppressor).isInstanceOf(Closer.SuppressingSuppressor.class);
   }

   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());
   }

   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 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 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 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 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 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 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 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 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 testNullCloseable() throws IOException {
     Closer closer = Closer.create();
     closer.register(null);
     closer.close();
   }

   static Throwable[] getSuppressed(Throwable throwable) {
     try {
       Method getSuppressed = Throwable.class.getDeclaredMethod("getSuppressed");
       return (Throwable[]) getSuppressed.invoke(throwable);
     } catch (Exception e) {
       throw new AssertionError(e); // only called if running on JDK7
     }
   }

   /**
    * Asserts that an exception was thrown when trying to close each of the given throwables and that
    * each such exception was suppressed because of the given thrown exception.
    */
   private void assertSuppressed(Suppression... expected) {
     assertEquals(ImmutableList.copyOf(expected), suppressor.suppressions);
   }

   /** Suppressor that records suppressions. */
   private static class TestSuppressor implements Closer.Suppressor {

     private final List<Suppression> suppressions = Lists.newArrayList();

     @Override
     public void suppress(Closeable closeable, Throwable thrown, Throwable suppressed) {
       suppressions.add(new Suppression(closeable, thrown, suppressed));
     }
   }

   /** Record of a call to suppress. */
   private static class Suppression {
     private final Closeable closeable;
     private final Throwable thrown;
     private final Throwable suppressed;

     private Suppression(Closeable closeable, Throwable thrown, Throwable suppressed) {
       this.closeable = closeable;
       this.thrown = thrown;
       this.suppressed = suppressed;
     }

     @Override
     public boolean equals(Object obj) {
       if (obj instanceof Suppression) {
         Suppression other = (Suppression) obj;
         return closeable.equals(other.closeable)
             && thrown.equals(other.thrown)
             && suppressed.equals(other.suppressed);
       }
       return false;
     }

     @Override
     public int hashCode() {
       return Objects.hashCode(closeable, thrown, suppressed);
     }

     @Override
     public String toString() {
       return MoreObjects.toStringHelper(this)
           .add("closeable", closeable)
           .add("thrown", thrown)
           .add("suppressed", suppressed)
           .toString();
     }
   }

   private static class TestCloseable implements Closeable {

     private final Throwable throwOnClose;
     private boolean closed;

     static TestCloseable normal() throws IOException {
       return new TestCloseable(null);
     }

     static TestCloseable throwsOnClose(Throwable throwOnClose) throws IOException {
       return new TestCloseable(throwOnClose);
     }

     static TestCloseable throwsOnCreate() throws IOException {
       throw new IOException();
     }

     private TestCloseable(@NullableDecl Throwable throwOnClose) {
       this.throwOnClose = throwOnClose;
     }

     public boolean isClosed() {
       return closed;
     }

     @Override
     public void close() throws IOException {
       closed = true;
       if (throwOnClose != null) {
         Throwables.propagateIfPossible(throwOnClose, IOException.class);
         throw new AssertionError(throwOnClose);
       }
     }
   }
 }
	/*
	* Copyright (C) 2012 The Guava Authors
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package com.google.common.io;

	import static com.google.common.truth.Truth.assertThat;

	import com.google.common.base.MoreObjects;
	import com.google.common.base.Objects;
	import com.google.common.base.Throwables;
	import com.google.common.collect.ImmutableList;
	import com.google.common.collect.ImmutableSet;
	import com.google.common.collect.Lists;
	import com.google.common.testing.TestLogHandler;
	import java.io.Closeable;
	import java.io.IOException;
	import java.lang.reflect.Method;
	import java.util.List;
	import java.util.logging.LogRecord;
	import junit.framework.TestCase;
	import org.checkerframework.checker.nullness.compatqual.NullableDecl;

	/**
	* Tests for {@link Closer}.
	*
	* @author Colin Decker
	*/
	public class CloserTest extends TestCase {

	private TestSuppressor suppressor;

	@Override
	protected void setUp() throws Exception {
	suppressor = new TestSuppressor();
	}

	@AndroidIncompatible // TODO(cpovirk): Look up Build.VERSION.SDK_INT reflectively.
	public void testCreate() {
	assertThat(Closer.create().suppressor).isInstanceOf(Closer.SuppressingSuppressor.class);
	}

	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());
	}

	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 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 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 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 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 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 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 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 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 testNullCloseable() throws IOException {
	Closer closer = Closer.create();
	closer.register(null);
	closer.close();
	}

	static Throwable[] getSuppressed(Throwable throwable) {
	try {
	Method getSuppressed = Throwable.class.getDeclaredMethod("getSuppressed");
	return (Throwable[]) getSuppressed.invoke(throwable);
	} catch (Exception e) {
	throw new AssertionError(e); // only called if running on JDK7
	}
	}

	/**
	* Asserts that an exception was thrown when trying to close each of the given throwables and that
	* each such exception was suppressed because of the given thrown exception.
	*/
	private void assertSuppressed(Suppression... expected) {
	assertEquals(ImmutableList.copyOf(expected), suppressor.suppressions);
	}

	/** Suppressor that records suppressions. */
	private static class TestSuppressor implements Closer.Suppressor {

	private final List<Suppression> suppressions = Lists.newArrayList();

	@Override
	public void suppress(Closeable closeable, Throwable thrown, Throwable suppressed) {
	suppressions.add(new Suppression(closeable, thrown, suppressed));
	}
	}

	/** Record of a call to suppress. */
	private static class Suppression {
	private final Closeable closeable;
	private final Throwable thrown;
	private final Throwable suppressed;

	private Suppression(Closeable closeable, Throwable thrown, Throwable suppressed) {
	this.closeable = closeable;
	this.thrown = thrown;
	this.suppressed = suppressed;
	}

	@Override
	public boolean equals(Object obj) {
	if (obj instanceof Suppression) {
	Suppression other = (Suppression) obj;
	return closeable.equals(other.closeable)
	&& thrown.equals(other.thrown)
	&& suppressed.equals(other.suppressed);
	}
	return false;
	}

	@Override
	public int hashCode() {
	return Objects.hashCode(closeable, thrown, suppressed);
	}

	@Override
	public String toString() {
	return MoreObjects.toStringHelper(this)
	.add("closeable", closeable)
	.add("thrown", thrown)
	.add("suppressed", suppressed)
	.toString();
	}
	}

	private static class TestCloseable implements Closeable {

	private final Throwable throwOnClose;
	private boolean closed;

	static TestCloseable normal() throws IOException {
	return new TestCloseable(null);
	}

	static TestCloseable throwsOnClose(Throwable throwOnClose) throws IOException {
	return new TestCloseable(throwOnClose);
	}

	static TestCloseable throwsOnCreate() throws IOException {
	throw new IOException();
	}

	private TestCloseable(@NullableDecl Throwable throwOnClose) {
	this.throwOnClose = throwOnClose;
	}

	public boolean isClosed() {
	return closed;
	}

	@Override
	public void close() throws IOException {
	closed = true;
	if (throwOnClose != null) {
	Throwables.propagateIfPossible(throwOnClose, IOException.class);
	throw new AssertionError(throwOnClose);
	}
	}
	}
	}