diff --git a/modules/luni/make/exclude.common b/modules/luni/make/exclude.common
index 3d3b327..9ce6e48 100644
--- a/modules/luni/make/exclude.common
+++ b/modules/luni/make/exclude.common
@@ -1,3 +1 @@
 org/apache/harmony/luni/tests/java/net/ExcludedProxyTest.java
-org/apache/harmony/luni/tests/java/io/OutputStreamTesterTest.java
-org/apache/harmony/luni/tests/java/io/WriterTesterTest.java
diff --git a/modules/luni/src/main/java/java/io/BufferedOutputStream.java b/modules/luni/src/main/java/java/io/BufferedOutputStream.java
index a78b155..598298c 100644
--- a/modules/luni/src/main/java/java/io/BufferedOutputStream.java
+++ b/modules/luni/src/main/java/java/io/BufferedOutputStream.java
@@ -88,6 +88,10 @@
      */
     @Override
     public synchronized void flush() throws IOException {
+        if (buf == null) {
+            throw new IOException(Msg.getString("K0059")); //$NON-NLS-1$
+        }
+
         flushInternal();
         out.flush();
     }
@@ -120,12 +124,17 @@
     @Override
     public synchronized void write(byte[] buffer, int offset, int length)
             throws IOException {
+        byte[] internalBuffer = buf;
+        if (internalBuffer == null) {
+            throw new IOException(Msg.getString("K0059")); //$NON-NLS-1$
+        }
+
         if (buffer == null) {
             // K0047=buffer is null
             throw new NullPointerException(Msg.getString("K0047")); //$NON-NLS-1$
         }
         
-        if (length >= buf.length) {
+        if (length >= internalBuffer.length) {
             flushInternal();
             out.write(buffer, offset, length);
             return;
@@ -142,15 +151,27 @@
         }
 
         // flush the internal buffer first if we have not enough space left
-        if (length >= (buf.length - count)) {
+        if (length >= (internalBuffer.length - count)) {
             flushInternal();
         }
 
-        // the length is always less than (buf.length - count) here so arraycopy is safe
-        System.arraycopy(buffer, offset, buf, count, length);
+        // the length is always less than (internalBuffer.length - count) here so arraycopy is safe
+        System.arraycopy(buffer, offset, internalBuffer, count, length);
         count += length;
     }
 
+    @Override public synchronized void close() throws IOException {
+        if (buf == null) {
+            return;
+        }
+        
+        try {
+            super.close();
+        } finally {
+            buf = null;
+        }
+    }
+
     /**
      * Writes one byte to this stream. Only the low order byte of the integer
      * {@code oneByte} is written. If there is room in the buffer, the byte is
@@ -165,11 +186,16 @@
      */
     @Override
     public synchronized void write(int oneByte) throws IOException {
-        if (count == buf.length) {
-            out.write(buf, 0, count);
+        byte[] internalBuffer = buf;
+        if (internalBuffer == null) {
+            throw new IOException(Msg.getString("K0059")); //$NON-NLS-1$
+        }
+
+        if (count == internalBuffer.length) {
+            out.write(internalBuffer, 0, count);
             count = 0;
         }
-        buf[count++] = (byte) oneByte;
+        internalBuffer[count++] = (byte) oneByte;
     }
 
     /**
@@ -178,7 +204,7 @@
     private void flushInternal() throws IOException {
         if (count > 0) {
             out.write(buf, 0, count);
+            count = 0;
         }
-        count = 0;
     }
 }
diff --git a/modules/luni/src/main/java/java/io/BufferedWriter.java b/modules/luni/src/main/java/java/io/BufferedWriter.java
index c9ff83c..72e8b62 100644
--- a/modules/luni/src/main/java/java/io/BufferedWriter.java
+++ b/modules/luni/src/main/java/java/io/BufferedWriter.java
@@ -21,6 +21,7 @@
 
 import org.apache.harmony.luni.util.Msg;
 import org.apache.harmony.luni.util.PriviAction;
+import org.apache.harmony.luni.util.SneakyThrow;
 
 /**
  * Wraps an existing {@link Writer} and <em>buffers</em> the output. Expensive
@@ -95,11 +96,29 @@
     @Override
     public void close() throws IOException {
         synchronized (lock) {
-            if (!isClosed()) {
+            if (isClosed()) {
+                return;
+            }
+
+            Throwable thrown = null;
+            try {
                 flushInternal();
+            } catch (Throwable e) {
+                thrown = e;
+            }
+            buf = null;
+
+            try {
                 out.close();
-                buf = null;
-                out = null;
+            } catch (Throwable e) {
+                if (thrown == null) {
+                    thrown = e;
+                }
+            }
+            out = null;
+
+            if (thrown != null) {
+                SneakyThrow.sneakyThrow(thrown);
             }
         }
     }
diff --git a/modules/luni/src/main/java/java/io/FilterOutputStream.java b/modules/luni/src/main/java/java/io/FilterOutputStream.java
index f7a31bf..8f9db69 100644
--- a/modules/luni/src/main/java/java/io/FilterOutputStream.java
+++ b/modules/luni/src/main/java/java/io/FilterOutputStream.java
@@ -18,6 +18,7 @@
 package java.io;
 
 import org.apache.harmony.luni.util.Msg;
+import org.apache.harmony.luni.util.SneakyThrow;
 
 /**
  * Wraps an existing {@link OutputStream} and performs some transformation on
@@ -55,27 +56,23 @@
      */
     @Override
     public void close() throws IOException {
-        Exception thrown = null;
+        Throwable thrown = null;
         try {
             flush();
-        } catch (Exception e) {
+        } catch (Throwable e) {
             thrown = e;
         }
 
         try {
             out.close();
-        } catch (Exception e) {
-            if (thrown != null) {
+        } catch (Throwable e) {
+            if (thrown == null) {
                 thrown = e;
             }
         }
 
         if (thrown != null) {
-            if (thrown instanceof IOException) {
-                throw (IOException) thrown;
-            } else {
-                throw (RuntimeException) thrown;
-            }
+            SneakyThrow.sneakyThrow(thrown);
         }
     }
 
diff --git a/modules/luni/src/main/java/org/apache/harmony/luni/util/SneakyThrow.java b/modules/luni/src/main/java/org/apache/harmony/luni/util/SneakyThrow.java
new file mode 100644
index 0000000..6e5e7d4
--- /dev/null
+++ b/modules/luni/src/main/java/org/apache/harmony/luni/util/SneakyThrow.java
@@ -0,0 +1,70 @@
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one or more
+ *  contributor license agreements.  See the NOTICE file distributed with
+ *  this work for additional information regarding copyright ownership.
+ *  The ASF licenses this file to You 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 org.apache.harmony.luni.util;
+
+/**
+ * Exploits a weakness in the runtime to throw an arbitrary throwable without
+ * the traditional declaration. <strong>This is a dangerous API that should be
+ * used with great caution.</strong> Typically this is useful when rethrowing
+ * throwables that are of a known range of types.
+ *
+ * <p>The following code must enumerate several types to rethrow:
+ * <pre>
+ * public void close() throws IOException {
+ *     Throwable thrown = null;
+ *     ...
+ *
+ *     if (thrown != null) {
+ *         if (thrown instanceof IOException) {
+ *             throw (IOException) thrown;
+ *         } else if (thrown instanceof RuntimeException) {
+ *             throw (RuntimeException) thrown;
+ *         } else if (thrown instanceof Error) {
+ *             throw (Error) thrown;
+ *         } else {
+ *             throw new AssertionError();
+ *         }
+ *     }
+ * }</pre>
+ * With SneakyThrow, rethrowing is easier:
+ * <pre>
+ * public void close() throws IOException {
+ *     Throwable thrown = null;
+ *     ...
+ *
+ *     if (thrown != null) {
+ *         SneakyThrow.sneakyThrow(thrown);
+ *     }
+ * }</pre>
+ */
+public final class SneakyThrow {
+    private SneakyThrow() {}
+
+    public static void sneakyThrow(Throwable t) {
+        SneakyThrow.<Error>sneakyThrow2(t);
+    }
+
+    /**
+     * Exploits unsafety to throw an exception that the compiler wouldn't permit
+     * but that the runtime doesn't check. See Java Puzzlers #43.
+     */
+    @SuppressWarnings("unchecked")
+    private static <T extends Throwable> void sneakyThrow2(Throwable t) throws T {
+        throw (T) t;
+    }
+}
diff --git a/modules/luni/src/test/api/common/org/apache/harmony/luni/tests/java/io/BufferedOutputStreamTest.java b/modules/luni/src/test/api/common/org/apache/harmony/luni/tests/java/io/BufferedOutputStreamTest.java
index 6c11f72..29a890c 100644
--- a/modules/luni/src/test/api/common/org/apache/harmony/luni/tests/java/io/BufferedOutputStreamTest.java
+++ b/modules/luni/src/test/api/common/org/apache/harmony/luni/tests/java/io/BufferedOutputStreamTest.java
@@ -328,9 +328,9 @@
 
         try {
             bos.write(byteArray, -1, -1);
-            fail("should throw ArrayIndexOutOfBoundsException");
-        } catch (ArrayIndexOutOfBoundsException e) {
-            // expected
+            fail();
+        } catch (Exception e) {
+            // expected IOException. RI throws IndexOutOfBoundsException
         }
     }
 
@@ -663,11 +663,6 @@
         buffos.flush();
 
         buffos.close();
-
-        buffos.write(Integer.MIN_VALUE);
-        buffos.write(Integer.MAX_VALUE);
-        buffos.write(buffer, 0, 10);
-        buffos.flush();
     }
 
     public void test_write_Scenario1() throws IOException {
@@ -751,8 +746,6 @@
             assertEquals(buffer2[i], byteArrayis.read());
         }
 
-        buffos.close();
-
         byte[] buffer3 = new byte[] { 'e', 'f', 'g', 'h', 'i' };
         buffos.write(buffer3, 0, 5);
         byteArrayis = new ByteArrayInputStream(byteArrayos.toByteArray());
@@ -778,6 +771,8 @@
         byteArrayis = new ByteArrayInputStream(byteArrayos.toByteArray());
         assertEquals("Bytes not written after flush", 21, byteArrayis
                 .available());
+
+        buffos.close();
     }
 
     public void test_write_Scenario3() throws IOException {
diff --git a/modules/luni/src/test/api/common/org/apache/harmony/luni/tests/java/io/OutputStreamTesterTest.java b/modules/luni/src/test/api/common/org/apache/harmony/luni/tests/java/io/OutputStreamTesterTest.java
index b025e04..20362d5 100644
--- a/modules/luni/src/test/api/common/org/apache/harmony/luni/tests/java/io/OutputStreamTesterTest.java
+++ b/modules/luni/src/test/api/common/org/apache/harmony/luni/tests/java/io/OutputStreamTesterTest.java
@@ -54,8 +54,8 @@
         // sink tests
         suite.addTest(new FileOutputStreamSinkTester(true).createTests());
         suite.addTest(new FileOutputStreamSinkTester(false).createTests());
-        suite.addTest(new ByteArrayOutputStreamSinkTester(0).createTests());
-        suite.addTest(new ByteArrayOutputStreamSinkTester(4).createTests());
+        suite.addTest(new ByteArrayOutputStreamSinkTester(0).setThrowsExceptions(false).createTests());
+        suite.addTest(new ByteArrayOutputStreamSinkTester(4).setThrowsExceptions(false).createTests());
         suite.addTest(new PipedOutputStreamSinkTester().createTests());
 
         // wrapper tests
@@ -64,7 +64,8 @@
         suite.addTest(new BufferedOutputStreamTester(1024).createTests());
         suite.addTest(new FilterOutputStreamTester().createTests());
         suite.addTest(new DataOutputStreamTester().createTests());
-        suite.addTest(new ObjectOutputStreamTester().createTests());
+        // fails wrapperTestFlushThrowsViaClose() and sinkTestWriteAfterClose():
+        // suite.addTest(new ObjectOutputStreamTester().createTests());
         suite.addTest(new PrintStreamTester().setThrowsExceptions(false).createTests());
 
         return suite;
diff --git a/modules/luni/src/test/api/common/org/apache/harmony/luni/tests/java/io/WriterTesterTest.java b/modules/luni/src/test/api/common/org/apache/harmony/luni/tests/java/io/WriterTesterTest.java
index 1d64d1d..910c787 100644
--- a/modules/luni/src/test/api/common/org/apache/harmony/luni/tests/java/io/WriterTesterTest.java
+++ b/modules/luni/src/test/api/common/org/apache/harmony/luni/tests/java/io/WriterTesterTest.java
@@ -52,8 +52,8 @@
         // sink tests
         suite.addTest(new FileWriterCharSinkTester(true).createTests());
         suite.addTest(new FileWriterCharSinkTester(false).createTests());
-        suite.addTest(new CharArrayWriterCharSinkTester().createTests());
-        suite.addTest(new StringWriterCharSinkTester().createTests());
+        suite.addTest(new CharArrayWriterCharSinkTester().setThrowsExceptions(false).createTests());
+        suite.addTest(new StringWriterCharSinkTester().setThrowsExceptions(false).createTests());
         suite.addTest(new PipedWriterCharSinkTester().createTests());
 
         // wrapper tests
diff --git a/support/src/test/java/org/apache/harmony/testframework/CharSinkTester.java b/support/src/test/java/org/apache/harmony/testframework/CharSinkTester.java
index 97ee1bb..8aa9db4 100644
--- a/support/src/test/java/org/apache/harmony/testframework/CharSinkTester.java
+++ b/support/src/test/java/org/apache/harmony/testframework/CharSinkTester.java
@@ -67,6 +67,8 @@
 
         if (throwsExceptions) {
             result.addTest(new SinkTestCase("sinkTestWriteAfterClose"));
+        } else {
+            result.addTest(new SinkTestCase("sinkTestWriteAfterCloseSuppressed"));
         }
 
         return result;
@@ -184,6 +186,13 @@
             Assert.assertArrayEquals(expectedChars, getChars());
         }
 
+        public void sinkTestWriteAfterCloseSuppressed() throws Exception {
+            Writer out = create();
+            out.write("EF".toCharArray());
+            out.close();
+            out.write("GCDE".toCharArray()); // no exception expected!
+        }
+
         // adding a new test? Don't forget to update createTests().
 
         @Override public String getName() {
diff --git a/support/src/test/java/org/apache/harmony/testframework/CharWrapperTester.java b/support/src/test/java/org/apache/harmony/testframework/CharWrapperTester.java
index bbdb56d..2744eed 100644
--- a/support/src/test/java/org/apache/harmony/testframework/CharWrapperTester.java
+++ b/support/src/test/java/org/apache/harmony/testframework/CharWrapperTester.java
@@ -21,7 +21,6 @@
 import junit.framework.TestSuite;
 
 import java.io.IOException;
-import java.io.StringWriter;
 import java.io.Writer;
 
 /**
@@ -63,9 +62,11 @@
         if (throwsExceptions) {
             result.addTest(new WrapperTestCase("wrapperTestFlushThrowsViaFlush"));
             result.addTest(new WrapperTestCase("wrapperTestFlushThrowsViaClose"));
+            result.addTest(new WrapperTestCase("wrapperTestCloseThrows"));
         } else {
             result.addTest(new WrapperTestCase("wrapperTestFlushThrowsViaFlushSuppressed"));
             result.addTest(new WrapperTestCase("wrapperTestFlushThrowsViaCloseSuppressed"));
+            result.addTest(new WrapperTestCase("wrapperTestCloseThrowsSuppressed"));
         }
 
         return result;
@@ -76,15 +77,15 @@
     }
 
     private class WrapperSinkTester extends CharSinkTester {
-        private StringWriter delegate;
+        private ClosableStringWriter delegate;
 
         @Override public Writer create() throws Exception {
-            delegate = new StringWriter();
+            delegate = new ClosableStringWriter();
             return CharWrapperTester.this.create(delegate);
         }
 
         @Override public char[] getChars() throws Exception {
-            return CharWrapperTester.this.decode(delegate.toString().toCharArray());
+            return decode(delegate.buffer.toString().toCharArray());
         }
 
         @Override public String toString() {
@@ -98,6 +99,10 @@
             super(name);
         }
 
+        @Override public String getName() {
+            return CharWrapperTester.this.toString() + ":" + super.getName();
+        }
+
         public void wrapperTestFlushThrowsViaFlushSuppressed() throws Exception {
             FailOnFlushWriter delegate = new FailOnFlushWriter();
             Writer o = create(delegate);
@@ -154,27 +159,83 @@
             }
         }
 
-        // adding a new test? Don't forget to update createTests().
-
-        @Override public String getName() {
-            return CharWrapperTester.this.toString() + ":" + super.getName();
+        public void wrapperTestCloseThrows() throws Exception {
+            FailOnCloseWriter delegate = new FailOnCloseWriter();
+            Writer o = create(delegate);
+            try {
+                o.close();
+                assertTrue(delegate.closed);
+                fail("close exception ignored");
+            } catch (IOException expected) {
+                assertEquals("Close failed" , expected.getMessage());
+            }
         }
 
-        private class FailOnFlushWriter extends Writer {
-            boolean flushed = false;
+        public void wrapperTestCloseThrowsSuppressed() throws Exception {
+            FailOnCloseWriter delegate = new FailOnCloseWriter();
+            Writer o = create(delegate);
+            o.close();
+            assertTrue(delegate.closed);
+        }
 
-            @Override public void write(char[] buf, int offset, int count) throws IOException {}
+        // adding a new test? Don't forget to update createTests().
+    }
 
-            @Override public void close() throws IOException {
-                flush();
+    /**
+     * A custom Writer that respects the closed state. The built-in StringWriter
+     * doesn't respect close(), which makes testing wrapped streams difficult.
+     */
+    private static class ClosableStringWriter extends Writer {
+        private final StringBuilder buffer = new StringBuilder();
+        private boolean closed = false;
+
+        @Override public void close() throws IOException {
+            closed = true;
+        }
+
+        @Override public void flush() throws IOException {}
+
+        @Override public void write(char[] buf, int offset, int count) throws IOException {
+            if (closed) {
+                throw new IOException();
             }
+            buffer.append(buf, offset, count);
+        }
+    }
 
-            @Override public void flush() throws IOException {
-                if (!flushed) {
-                    flushed = true;
-                    throw new IOException("Flush failed");
-                }
+    private static class FailOnFlushWriter extends Writer {
+        boolean flushed = false;
+        boolean closed = false;
+
+        @Override public void write(char[] buf, int offset, int count) throws IOException {
+            if (closed) {
+                throw new IOException("Already closed");
             }
         }
+
+        @Override public void close() throws IOException {
+            closed = true;
+            flush();
+        }
+
+        @Override public void flush() throws IOException {
+            if (!flushed) {
+                flushed = true;
+                throw new IOException("Flush failed");
+            }
+        }
+    }
+
+    private static class FailOnCloseWriter extends Writer {
+        boolean closed = false;
+
+        @Override public void flush() throws IOException {}
+
+        @Override public void write(char[] buf, int offset, int count) throws IOException {}
+
+        @Override public void close() throws IOException {
+            closed = true;
+            throw new IOException("Close failed");
+        }
     }
 }
\ No newline at end of file
diff --git a/support/src/test/java/org/apache/harmony/testframework/SinkTester.java b/support/src/test/java/org/apache/harmony/testframework/SinkTester.java
index f8aaf8e..aceec1c 100644
--- a/support/src/test/java/org/apache/harmony/testframework/SinkTester.java
+++ b/support/src/test/java/org/apache/harmony/testframework/SinkTester.java
@@ -68,6 +68,8 @@
 
         if (throwsExceptions) {
             result.addTest(new SinkTestCase("sinkTestWriteAfterClose"));
+        } else {
+            result.addTest(new SinkTestCase("sinkTestWriteAfterCloseSuppressed"));
         }
 
         return result;
@@ -196,6 +198,13 @@
             Assert.assertArrayEquals(expectedBytes, getBytes());
         }
 
+        public void sinkTestWriteAfterCloseSuppressed() throws Exception {
+            OutputStream out = create();
+            out.write(new byte[] { 5, 6 });
+            out.close();
+            out.write(new byte[] { 7, 3, 4, 5 }); // no exception expected!
+        }
+
         // adding a new test? Don't forget to update createTests().
 
         @Override public String getName() {
diff --git a/support/src/test/java/org/apache/harmony/testframework/WrapperTester.java b/support/src/test/java/org/apache/harmony/testframework/WrapperTester.java
index ee54221..b5594c4 100644
--- a/support/src/test/java/org/apache/harmony/testframework/WrapperTester.java
+++ b/support/src/test/java/org/apache/harmony/testframework/WrapperTester.java
@@ -63,9 +63,11 @@
         if (throwsExceptions) {
             result.addTest(new WrapperTestCase("wrapperTestFlushThrowsViaFlush"));
             result.addTest(new WrapperTestCase("wrapperTestFlushThrowsViaClose"));
+            result.addTest(new WrapperTestCase("wrapperTestCloseThrows"));
         } else {
             result.addTest(new WrapperTestCase("wrapperTestFlushThrowsViaFlushSuppressed"));
             result.addTest(new WrapperTestCase("wrapperTestFlushThrowsViaCloseSuppressed"));
+            result.addTest(new WrapperTestCase("wrapperTestCloseThrowsSuppressed"));
         }
 
         return result;
@@ -76,15 +78,15 @@
     }
 
     private class WrapperSinkTester extends SinkTester {
-        private ByteArrayOutputStream delegate;
+        private ClosableByteArrayOutputStream delegate;
 
         @Override public OutputStream create() throws Exception {
-            delegate = new ByteArrayOutputStream();
+            delegate = new ClosableByteArrayOutputStream();
             return WrapperTester.this.create(delegate);
         }
 
         @Override public byte[] getBytes() throws Exception {
-            return WrapperTester.this.decode(delegate.toByteArray());
+            return WrapperTester.this.decode(delegate.bytesOut.toByteArray());
         }
 
         @Override public String toString() {
@@ -98,6 +100,10 @@
             super(name);
         }
 
+        @Override public String getName() {
+            return WrapperTester.this.toString() + ":" + super.getName();
+        }
+
         public void wrapperTestFlushThrowsViaFlushSuppressed() throws Exception {
             FailOnFlushOutputStream delegate = new FailOnFlushOutputStream();
             OutputStream o = create(delegate);
@@ -154,27 +160,73 @@
             }
         }
 
-        // adding a new test? Don't forget to update createTests().
-
-        @Override public String getName() {
-            return WrapperTester.this.toString() + ":" + super.getName();
+        public void wrapperTestCloseThrows() throws Exception {
+            FailOnCloseOutputStream delegate = new FailOnCloseOutputStream();
+            OutputStream o = create(delegate);
+            try {
+                o.close();
+                assertTrue(delegate.closed);
+                fail("close exception ignored");
+            } catch (IOException expected) {
+                assertEquals("Close failed" , expected.getMessage());
+            }
         }
 
-        private class FailOnFlushOutputStream extends ByteArrayOutputStream {
-            boolean flushed = false;
+        public void wrapperTestCloseThrowsSuppressed() throws Exception {
+            FailOnCloseOutputStream delegate = new FailOnCloseOutputStream();
+            OutputStream o = create(delegate);
+            o.close();
+            assertTrue(delegate.closed);
+        }
 
-            @Override public void close() throws IOException {
-                flush();
-                super.close();
-            }
+        // adding a new test? Don't forget to update createTests().
+    }
 
-            @Override public void flush() throws IOException {
-                if (!flushed) {
-                    flushed = true;
-                    throw new IOException("Flush failed");
-                }
-                super.flush();
+    private static class ClosableByteArrayOutputStream extends OutputStream {
+        private final ByteArrayOutputStream bytesOut = new ByteArrayOutputStream();
+        private boolean closed = false;
+
+        @Override public void close() throws IOException {
+            closed = true;
+        }
+
+        @Override public void write(int oneByte) throws IOException {
+            if (closed) {
+                throw new IOException();
             }
+            bytesOut.write(oneByte);
+        }
+    }
+
+    private static class FailOnFlushOutputStream extends OutputStream {
+        boolean flushed = false;
+        boolean closed = false;
+
+        @Override public void write(int oneByte) throws IOException {
+            if (closed) {
+                throw new IOException("Already closed");
+            }
+        }
+
+        @Override public void close() throws IOException {
+            closed = true;
+            flush();
+        }
+
+        @Override public void flush() throws IOException {
+            if (!flushed) {
+                flushed = true;
+                throw new IOException("Flush failed");
+            }
+        }
+    }
+
+    private static class FailOnCloseOutputStream extends ByteArrayOutputStream {
+        boolean closed = false;
+
+        @Override public void close() throws IOException {
+            closed = true;
+            throw new IOException("Close failed");
         }
     }
 }