diff --git a/libcore/luni/src/main/java/java/io/PipedInputStream.java b/libcore/luni/src/main/java/java/io/PipedInputStream.java
index 6d1c007..507371b 100644
--- a/libcore/luni/src/main/java/java/io/PipedInputStream.java
+++ b/libcore/luni/src/main/java/java/io/PipedInputStream.java
@@ -59,7 +59,7 @@
      * {@code in == out}. Writing when the buffer is full will block until free
      * space is available.
      */
-    protected byte buffer[];
+    protected byte[] buffer;
 
     /**
      * The index in {@code buffer} where the next byte will be written.
@@ -103,6 +103,40 @@
     }
 
     /**
+     * Constructs a new unconnected {@code PipedInputStream} with the given
+     * buffer size. The resulting stream must be connected to a
+     * {@code PipedOutputStream} before data may be read from it.
+     * 
+     * @param pipeSize the size of the buffer in bytes.
+     * @throws IllegalArgumentException if pipeSize is less than or equal to zero.
+     * @since 1.6
+     * @hide
+     */
+    public PipedInputStream(int pipeSize) {
+        if (pipeSize <= 0) {
+            throw new IllegalArgumentException("pipe size " + pipeSize + " too small");
+        }
+        buffer = new byte[pipeSize];
+    }
+
+    /**
+     * Constructs a new {@code PipedInputStream} connected to the given {@code PipedOutputStream},
+     * with the given buffer size. Any data written to the output stream can be read from this
+     * input stream.
+     * 
+     * @param out the {@code PipedOutputStream} to connect to.
+     * @param pipeSize the size of the buffer in bytes.
+     * @throws IOException if an I/O error occurs.
+     * @throws IllegalArgumentException if pipeSize is less than or equal to zero.
+     * @since 1.6
+     * @hide
+     */
+    public PipedInputStream(PipedOutputStream out, int pipeSize) throws IOException {
+        this(pipeSize);
+        connect(out);
+    }
+
+    /**
      * Returns the number of bytes that are available before this stream will
      * block. This implementation returns the number of bytes written to this
      * pipe that have not been read yet.
@@ -156,7 +190,9 @@
         if (isConnected) {
             throw new IOException(Msg.getString("K007a")); //$NON-NLS-1$
         }
-        buffer = new byte[PipedInputStream.PIPE_SIZE];
+        if (buffer == null) { // We may already have allocated the buffer.
+            buffer = new byte[PipedInputStream.PIPE_SIZE];
+        }
         isConnected = true;
     }
 
diff --git a/libcore/luni/src/main/java/java/io/PipedReader.java b/libcore/luni/src/main/java/java/io/PipedReader.java
index d137a0d..29319fa 100644
--- a/libcore/luni/src/main/java/java/io/PipedReader.java
+++ b/libcore/luni/src/main/java/java/io/PipedReader.java
@@ -103,6 +103,40 @@
     }
 
     /**
+     * Constructs a new unconnected {@code PipedReader} with the given buffer size.
+     * The resulting reader must be connected to a {@code PipedWriter} before
+     * data may be read from it.
+     * 
+     * @param pipeSize the size of the buffer in chars.
+     * @throws IllegalArgumentException if pipeSize is less than or equal to zero.
+     * @since 1.6
+     * @hide
+     */
+    public PipedReader(int pipeSize) {
+        if (pipeSize <= 0) {
+            throw new IllegalArgumentException("pipe size " + pipeSize + " too small");
+        }
+        buffer = new char[pipeSize];
+    }
+
+    /**
+     * Constructs a new {@code PipedReader} connected to the given {@code PipedWriter},
+     * with the given buffer size. Any data written to the writer can be read from
+     * this reader.
+     * 
+     * @param out the {@code PipedWriter} to connect to.
+     * @param pipeSize the size of the buffer in chars.
+     * @throws IOException if an I/O error occurs
+     * @throws IllegalArgumentException if pipeSize is less than or equal to zero.
+     * @since 1.6
+     * @hide
+     */
+    public PipedReader(PipedWriter out, int pipeSize) throws IOException {
+        this(pipeSize);
+        connect(out);
+    }
+
+    /**
      * Closes this reader. This implementation releases the buffer used for
      * the pipe and notifies all threads waiting to read or write.
      *
@@ -112,6 +146,7 @@
     @Override
     public synchronized void close() throws IOException {
         buffer = null;
+        isClosed = true;
         notifyAll();
     }
 
@@ -139,7 +174,9 @@
         if (isConnected) {
             throw new IOException(Msg.getString("K007a")); //$NON-NLS-1$
         }
-        buffer = new char[PIPE_SIZE];
+        if (buffer == null) { // We may already have allocated the buffer.
+            buffer = new char[PIPE_SIZE];
+        }
         isConnected = true;
     }
 
diff --git a/libcore/luni/src/test/java/tests/api/java/io/PipedInputStreamTest.java b/libcore/luni/src/test/java/tests/api/java/io/PipedInputStreamTest.java
index 671bfe9..b423659 100644
--- a/libcore/luni/src/test/java/tests/api/java/io/PipedInputStreamTest.java
+++ b/libcore/luni/src/test/java/tests/api/java/io/PipedInputStreamTest.java
@@ -20,121 +20,92 @@
 import java.io.PipedInputStream;
 import java.io.PipedOutputStream;
 
-import dalvik.annotation.TestLevel;
-import dalvik.annotation.TestTargetClass;
-import dalvik.annotation.TestTargetNew;
-
-@TestTargetClass(PipedInputStream.class) 
 public class PipedInputStreamTest extends junit.framework.TestCase {
 
-    static class PWriter implements Runnable {
-        PipedOutputStream pos;
+	static class PWriter implements Runnable {
+		PipedOutputStream pos;
 
-        public byte bytes[];
+		public byte bytes[];
 
-        public void run() {
-            try {
-                pos.write(bytes);   
-                synchronized (this) {
-                    notify();
-                }
-            } catch (Exception e) {
-                e.printStackTrace(System.out);
-                System.out.println("Error while running the writer thread.");
-            }
-        }
+		public void run() {
+			try {
+				pos.write(bytes);
+				synchronized (this) {
+					notify();
+				}
+			} catch (IOException e) {
+				e.printStackTrace(System.out);
+				System.out.println("Could not write bytes");
+			}
+		}
 
-        public PWriter(PipedOutputStream pout, int nbytes) {
-            pos = pout;
-            bytes = new byte[nbytes];
-            for (int i = 0; i < bytes.length; i++)
-                bytes[i] = (byte) (System.currentTimeMillis() % 9);
-        }
-    }
+		public PWriter(PipedOutputStream pout, int nbytes) {
+			pos = pout;
+			bytes = new byte[nbytes];
+			for (int i = 0; i < bytes.length; i++) {
+				bytes[i] = (byte) (System.currentTimeMillis() % 9);
+		    }
+		}
+	}
 
-    static class PWriter2 implements Runnable {
-        PipedOutputStream pos;
+	Thread t;
 
-        public boolean keepRunning = true;
+	PWriter pw;
 
-        public void run() {
-            try {
-                pos.write(42);
-                pos.close();
-                while (keepRunning) {
-                    Thread.sleep(1000);
-                }
-            } catch (Exception e) {
-                e.printStackTrace(System.out);
-                System.out.println("Error while running the writer thread.");
-            }
-        }
+	PipedInputStream pis;
 
-        public PWriter2(PipedOutputStream pout) {
-            pos = pout;
-        }
-    }
+	PipedOutputStream pos;
 
-    Thread t;
+	/**
+	 * @tests java.io.PipedInputStream#PipedInputStream()
+	 */
+	public void test_Constructor() {
+		// Test for method java.io.PipedInputStream()
+		// Used in tests
+	}
 
-    PWriter pw;
-
-    PipedInputStream pis;
-
-    PipedOutputStream pos;
-
-    /**
-     * @tests java.io.PipedInputStream#PipedInputStream()
-     */
-    @TestTargetNew(
-        level = TestLevel.COMPLETE,
-        notes = "",
-        method = "PipedInputStream",
-        args = {}
-    )
-    public void test_Constructor() throws IOException {
-        pis = new PipedInputStream();
-        assertEquals("There should not be any bytes available. ", 0, pis.available());
-        pis.close();
-    }
-
-    /**
-     * @tests java.io.PipedInputStream#PipedInputStream(java.io.PipedOutputStream)
-     */
-    @TestTargetNew(
-        level = TestLevel.COMPLETE,
-        notes = "",
-        method = "PipedInputStream",
-        args = {java.io.PipedOutputStream.class}
-    )
-    public void test_ConstructorLjava_io_PipedOutputStream() throws IOException {
-        pos = new PipedOutputStream(new PipedInputStream());
-        
-        try {
-            pis = new PipedInputStream(pos);
-            fail("IOException expected since the output stream is already connected.");
-        } catch (IOException e) {
-            // Expected.
-        }
-        
+	/**
+	 * @tests java.io.PipedInputStream#PipedInputStream(java.io.PipedOutputStream)
+	 */
+	public void test_ConstructorLjava_io_PipedOutputStream() throws Exception {
+        // Test for method java.io.PipedInputStream(java.io.PipedOutputStream)
         pis = new PipedInputStream(new PipedOutputStream());
-        assertEquals("There should not be any bytes available. ", 0, pis.available());
-        
-        pis.close();
-        pos.close();
+        pis.available();
+    }
+
+
+    /**
+     * @test java.io.PipedInputStream#read()
+     */
+    public void test_readException() throws IOException {
+        pis = new PipedInputStream();
+        pos = new PipedOutputStream();
+
+        try {
+            pis.connect(pos);
+            t = new Thread(pw = new PWriter(pos, 1000));
+            t.start();
+            assertTrue(t.isAlive());
+            while (true) {
+                pis.read();
+                t.interrupt();
+            }
+        } catch (IOException e) {
+            if (!e.getMessage().contains("Write end dead") && !e.getMessage().contains("Pipe broken")) { // android-changed
+                throw e;
+            }
+        } finally {
+            try {
+                pis.close();
+                pos.close();
+            } catch (IOException ee) {}
+        }
     }
 
     /**
      * @tests java.io.PipedInputStream#available()
      */
-    @TestTargetNew(
-        level = TestLevel.COMPLETE,
-        notes = "No IOException checking because it is never thrown in the source code.",
-        method = "available",
-        args = {}
-    )
     public void test_available() throws Exception {
-        // Test for method int java.io.PipedInputStream.available()
         pis = new PipedInputStream();
         pos = new PipedOutputStream();
 
@@ -145,63 +116,49 @@
         synchronized (pw) {
             pw.wait(10000);
         }
-        assertEquals("Test 1: Incorrect number of bytes available. ",
-                     1000, pis.available());
+        assertTrue("Available returned incorrect number of bytes: "
+                + pis.available(), pis.available() == 1000);
 
         PipedInputStream pin = new PipedInputStream();
         PipedOutputStream pout = new PipedOutputStream(pin);
         // We know the PipedInputStream buffer size is 1024.
         // Writing another byte would cause the write to wait
         // for a read before returning
-        for (int i = 0; i < 1024; i++)
+        for (int i = 0; i < 1024; i++) {
             pout.write(i);
-        assertEquals("Test 2: Incorrect number of bytes available. ", 
-                     1024 , pin.available());
+        }
+        assertEquals("Incorrect available count", 1024 , pin.available());
     }
 
-    /**
-     * @tests java.io.PipedInputStream#close()
-     */
-    @TestTargetNew(
-        level = TestLevel.COMPLETE,
-        notes = "No IOException checking because it is never thrown in the source code.",
-        method = "close",
-        args = {}
-    )
-    public void test_close() throws IOException {
-        // Test for method void java.io.PipedInputStream.close()
-        pis = new PipedInputStream();
-        pos = new PipedOutputStream();
+	/**
+	 * @tests java.io.PipedInputStream#close()
+	 */
+	public void test_close() throws IOException {
+		// Test for method void java.io.PipedInputStream.close()
+		pis = new PipedInputStream();
+		pos = new PipedOutputStream();
         pis.connect(pos);
         pis.close();
-        try {
-            pos.write((byte) 127);
-            fail("IOException expected.");
-        } catch (IOException e) {
-            // The spec for PipedInput says an exception should be thrown if
-            // a write is attempted to a closed input. The PipedOuput spec
-            // indicates that an exception should be thrown only when the
-            // piped input thread is terminated without closing
-            return;
-        }
-    }
+		try {
+			pos.write((byte) 127);
+            fail("Failed to throw expected exception");
+		} catch (IOException e) {
+			// The spec for PipedInput saya an exception should be thrown if
+			// a write is attempted to a closed input. The PipedOuput spec
+			// indicates that an exception should be thrown only when the
+			// piped input thread is terminated without closing
+			return;
+		}
+	}
 
-    /**
-     * @tests java.io.PipedInputStream#connect(java.io.PipedOutputStream)
-     */
-    @TestTargetNew(
-        level = TestLevel.COMPLETE,
-        notes = "",
-        method = "connect",
-        args = {java.io.PipedOutputStream.class}
-    )
-    public void test_connectLjava_io_PipedOutputStream() throws Exception {
-        // Test for method void
-        // java.io.PipedInputStream.connect(java.io.PipedOutputStream)
+	/**
+	 * @tests java.io.PipedInputStream#connect(java.io.PipedOutputStream)
+	 */
+	public void test_connectLjava_io_PipedOutputStream() throws Exception {
         pis = new PipedInputStream();
         pos = new PipedOutputStream();
-        assertEquals("Test 1: Not-connected pipe returned more than zero available bytes. ", 
-                     0, pis.available());
+        assertEquals("Non-conected pipe returned non-zero available bytes", 0,
+                pis.available());
 
         pis.connect(pos);
         t = new Thread(pw = new PWriter(pos, 1000));
@@ -210,142 +167,50 @@
         synchronized (pw) {
             pw.wait(10000);
         }
-        assertEquals("Test 2: Unexpected number of bytes available. ", 
-                     1000, pis.available());
-
-        try {
-            pis.connect(pos);
-            fail("Test 3: IOException expected when reconnecting the pipe.");
-        } catch (IOException e) {
-            // Expected.
-        }
-        
-        pis.close();
-        pos.close();
+        assertEquals("Available returned incorrect number of bytes", 1000, pis
+                .available());
     }
 
-    /**
-     * @tests java.io.PipedInputStream#read()
-     */
-    @TestTargetNew(
-        level = TestLevel.PARTIAL_COMPLETE,
-        notes = "",
-        method = "read",
-        args = {}
-    )
-    public void test_read() throws Exception {
+	/**
+	 * @tests java.io.PipedInputStream#read()
+	 */
+	public void test_read() throws Exception {
         pis = new PipedInputStream();
         pos = new PipedOutputStream();
 
-        try {
-            pis.read();
-            fail("Test 1: IOException expected since the stream is not connected.");
-        } catch (IOException e) {
-            // Expected.
-        }
-        
         pis.connect(pos);
-        t = new Thread(pw = new PWriter(pos, 100));
+        t = new Thread(pw = new PWriter(pos, 1000));
         t.start();
 
         synchronized (pw) {
-            pw.wait(5000);
+            pw.wait(10000);
         }
-        assertEquals("Test 2: Unexpected number of bytes available. ", 
-                     100, pis.available());
-        
-        for (int i = 0; i < 100; i++) {
-            assertEquals("Test 3: read() returned incorrect byte. ", 
-                         pw.bytes[i], (byte) pis.read());
-        }
-
-        try {
-            pis.read();
-            fail("Test 4: IOException expected since the thread that has " +
-                 "written to the pipe is no longer alive.");
-        } catch (IOException e) {
-            // Expected.
-        }
-
-        pis.close();
-        try {
-            pis.read();
-            fail("Test 5: IOException expected since the stream is closed.");
-        } catch (IOException e) {
-            // Expected.
-        }
+        assertEquals("Available returned incorrect number of bytes", 1000, pis
+                .available());
+        assertEquals("read returned incorrect byte", pw.bytes[0], (byte) pis
+                .read());
     }
 
-    /**
-     * @tests java.io.PipedInputStream#read()
-     */
-    @TestTargetNew(
-        level = TestLevel.PARTIAL_COMPLETE,
-        notes = "Checks that read returns -1 if the PipedOutputStream connected to this PipedInputStream is closed.",
-        method = "read",
-        args = {}
-    )
-    public void test_read_2() throws Exception {
-        Thread writerThread;
-        PWriter2 pwriter;
-        
-        pos = new PipedOutputStream(); 
-        pis = new PipedInputStream(pos);
-        writerThread = new Thread(pwriter = new PWriter2(pos));
-        writerThread.start();
+	/**
+	 * @tests java.io.PipedInputStream#read(byte[], int, int)
+	 */
+	public void test_read$BII() throws Exception {
+        pis = new PipedInputStream();
+        pos = new PipedOutputStream();
 
-        synchronized (pwriter) {
-            pwriter.wait(5000);
-        }
-        pis.read();
-        assertEquals("Test 1: No more data indication expected. ", -1, pis.read());
-        pwriter.keepRunning = false;
-        
-        pis.close();
-    }
+        pis.connect(pos);
+        t = new Thread(pw = new PWriter(pos, 1000));
+        t.start();
 
-    /**
-     * @tests java.io.PipedInputStream#read(byte[], int, int)
-     */
-    @TestTargetNew(
-        level = TestLevel.PARTIAL_COMPLETE,
-        notes = "Tests read from unconnected, connected and closed pipe.",
-        method = "read",
-        args = {byte[].class, int.class, int.class}
-    )
-    public void test_read$BII() throws Exception {
         byte[] buf = new byte[400];
-        pis = new PipedInputStream();
-        pos = new PipedOutputStream();
-
-        try {
-            pis.read(buf, 0, 10);
-            fail("Test 1: IOException expected since the stream is not connected.");
-        } catch (IOException e) {
-            // Expected.
-        }
-        
-        pis.connect(pos);
-        t = new Thread(pw = new PWriter(pos, 1000));
-        t.start();
-
         synchronized (pw) {
             pw.wait(10000);
         }
-        assertEquals("Test 2: Unexpected number of bytes available. ",
-                     1000, pis.available());
+        assertTrue("Available returned incorrect number of bytes: "
+                + pis.available(), pis.available() == 1000);
         pis.read(buf, 0, 400);
         for (int i = 0; i < 400; i++) {
-            assertEquals("Test 3: read() returned incorrect byte. ", 
-                         pw.bytes[i], buf[i]);
-        }
-        
-        pis.close();
-        try {
-            pis.read(buf, 0, 10);
-            fail("Test 4: IOException expected since the stream is closed.");
-        } catch (IOException e) {
-            // Expected.
+            assertEquals("read returned incorrect byte[]", pw.bytes[i], buf[i]);
         }
     }
 
@@ -353,20 +218,14 @@
      * @tests java.io.PipedInputStream#read(byte[], int, int)
      * Regression for HARMONY-387
      */
-    @TestTargetNew(
-        level = TestLevel.PARTIAL_COMPLETE,
-        notes = "Tests illegal length argument.",
-        method = "read",
-        args = {byte[].class, int.class, int.class}
-    )
     public void test_read$BII_2() throws IOException {
         PipedInputStream obj = new PipedInputStream();
         try {
             obj.read(new byte[0], 0, -1);
-            fail("IndexOutOfBoundsException expected.");
+            fail("IndexOutOfBoundsException expected");
         } catch (IndexOutOfBoundsException t) {
             assertEquals(
-                    "IndexOutOfBoundsException rather than a subclass expected.",
+                    "IndexOutOfBoundsException rather than a subclass expected",
                     IndexOutOfBoundsException.class, t.getClass());
         }
     }
@@ -374,46 +233,34 @@
     /**
      * @tests java.io.PipedInputStream#read(byte[], int, int)
      */
-    @TestTargetNew(
-        level = TestLevel.PARTIAL_COMPLETE,
-        notes = "Tests illegal offset argument.",
-        method = "read",
-        args = {byte[].class, int.class, int.class}
-    )
     public void test_read$BII_3() throws IOException {
         PipedInputStream obj = new PipedInputStream();
         try {
-            obj.read(new byte[10], -1, 1);
-            fail("IndexOutOfBoundsException expected.");
-        } catch (IndexOutOfBoundsException e) {
-            // Expected
-            assertTrue(e.getClass().equals(IndexOutOfBoundsException.class));
+            obj.read(new byte[0], -1, 0);
+            fail("IndexOutOfBoundsException expected");
+        } catch (ArrayIndexOutOfBoundsException t) {
+            fail("IndexOutOfBoundsException expected");
+        } catch (IndexOutOfBoundsException t) {
         }
+    }
+
+    /**
+     * @tests java.io.PipedInputStream#read(byte[], int, int)
+     */
+    public void test_read$BII_4() throws IOException {
+        PipedInputStream obj = new PipedInputStream();
         try {
-            obj.read(new byte[10], 0, -1);
-            fail("IndexOutOfBoundsException expected.");
-        } catch (IndexOutOfBoundsException e) {
-            // Expected
-            assertTrue(e.getClass().equals(IndexOutOfBoundsException.class));
-        }
-        try {
-            obj.read(new byte[10], 9, 2);
-            fail("IndexOutOfBoundsException expected.");
-        } catch (IndexOutOfBoundsException e) {
-            // Expected
-            assertTrue(e.getClass().equals(IndexOutOfBoundsException.class));
+            obj.read(new byte[0], -1, -1);
+            fail("IndexOutOfBoundsException expected");
+        } catch (ArrayIndexOutOfBoundsException t) {
+            fail("IndexOutOfBoundsException expected");
+        } catch (IndexOutOfBoundsException t) {
         }
     }
 
     /**
      * @tests java.io.PipedInputStream#receive(int)
      */
-    @TestTargetNew(
-        level = TestLevel.COMPLETE,
-        notes = "",
-        method = "receive",
-        args = {int.class}
-    )
     public void test_receive() throws IOException {
         pis = new PipedInputStream();
         pos = new PipedOutputStream();
@@ -424,13 +271,13 @@
 
             boolean pass = false;
 
-            boolean readerAlive = true;
+            volatile boolean readerAlive = true;
 
             public void run() {
                 try {
                     pos.write(1);
                     while (readerAlive) {
-                        Thread.sleep(100);
+                        ;
                     }
                     try {
                         // should throw exception since reader thread
@@ -440,9 +287,6 @@
                         pass = true;
                     }
                 } catch (IOException e) {
-                    // ignore
-                } catch (InterruptedException e) {
-                    // ignore
                 }
             }
         }
@@ -456,7 +300,8 @@
                 try {
                     pis.read();
                     pass = true;
-                } catch (IOException e) {}
+                } catch (IOException e) {
+                }
             }
         }
         ;
@@ -464,12 +309,14 @@
         Thread readThread = new Thread(readRunnable);
         writeThread.start();
         readThread.start();
-        while (readThread.isAlive())
+        while (readThread.isAlive()) {
             ;
+        }
         writeRunnable.readerAlive = false;
         assertTrue("reader thread failed to read", readRunnable.pass);
-        while (writeThread.isAlive())
+        while (writeThread.isAlive()) {
             ;
+        }
         assertTrue("writer thread failed to recognize dead reader",
                 writeRunnable.pass);
 
@@ -500,7 +347,8 @@
             try {
                 // wait for thread t to get to the call to pis.receive
                 Thread.sleep(100);
-            } catch (InterruptedException e) {}
+            } catch (InterruptedException e) {
+            }
             // now we close
             pos.close();
         }
@@ -515,17 +363,87 @@
                 myRun.pass);
     }
 
-    /**
-     * Tears down the fixture, for example, close a network connection. This
-     * method is called after a test is executed.
-     */
-    protected void tearDown() throws Exception {
-        try {
-            if (t != null) {
-                t.interrupt();
+	/**
+	 * Tears down the fixture, for example, close a network connection. This
+	 * method is called after a test is executed.
+	 */
+	protected void tearDown() throws Exception {
+		try {
+			if (t != null) {
+				t.interrupt();
             }
-        } catch (Exception ignore) {
-        }
+		} catch (Exception ignore) {
+		}
         super.tearDown();
+	}
+	
+	    
+     /**
+     * @tests java.io.PipedInputStream#PipedInputStream(java.io.PipedOutputStream,
+     *        int)
+     * @since 1.6
+     */
+    public void test_Constructor_LPipedOutputStream_I() throws Exception {
+        // Test for method java.io.PipedInputStream(java.io.PipedOutputStream,
+        // int)
+        MockPipedInputStream mpis = new MockPipedInputStream(
+                new PipedOutputStream(), 100);
+        int bufferLength = mpis.bufferLength();
+        assertEquals(100, bufferLength);
+        
+        try {
+            pis = new PipedInputStream(null, -1);
+            fail("Should throw IllegalArgumentException"); //$NON-NLS-1$
+        } catch (IllegalArgumentException e) {
+            // expected
+        }
+        
+        try {
+            pis = new PipedInputStream(null, 0);
+            fail("Should throw IllegalArgumentException"); //$NON-NLS-1$
+        } catch (IllegalArgumentException e) {
+            // expected
+        }
+    }
+
+    /**
+     * @tests java.io.PipedInputStream#PipedInputStream(int)
+     * @since 1.6
+     */
+    public void test_Constructor_I() throws Exception {
+        // Test for method java.io.PipedInputStream(int)
+        MockPipedInputStream mpis = new MockPipedInputStream(100);
+        int bufferLength = mpis.bufferLength();
+        assertEquals(100, bufferLength);
+
+        try {
+            pis = new PipedInputStream(-1);
+            fail("Should throw IllegalArgumentException"); //$NON-NLS-1$
+        } catch (IllegalArgumentException e) {
+            // expected
+        }
+        
+        try {
+            pis = new PipedInputStream(0);
+            fail("Should throw IllegalArgumentException"); //$NON-NLS-1$
+        } catch (IllegalArgumentException e) {
+            // expected
+        }
+    }
+	
+    static class MockPipedInputStream extends PipedInputStream {
+
+        public MockPipedInputStream(java.io.PipedOutputStream src,
+                int bufferSize) throws IOException {
+            super(src, bufferSize);
+        }
+
+        public MockPipedInputStream(int bufferSize) {
+            super(bufferSize);
+        }
+
+        public int bufferLength() {
+            return super.buffer.length;
+        }
     }
 }
diff --git a/libcore/luni/src/test/java/tests/api/java/io/PipedReaderTest.java b/libcore/luni/src/test/java/tests/api/java/io/PipedReaderTest.java
index f67790b..edbb5f5 100644
--- a/libcore/luni/src/test/java/tests/api/java/io/PipedReaderTest.java
+++ b/libcore/luni/src/test/java/tests/api/java/io/PipedReaderTest.java
@@ -17,17 +17,13 @@
 
 package tests.api.java.io;
 
-import dalvik.annotation.TestTargets;
-import dalvik.annotation.TestLevel;
-import dalvik.annotation.TestTargetNew;
-import dalvik.annotation.TestTargetClass; 
-
 import java.io.IOException;
 import java.io.PipedReader;
 import java.io.PipedWriter;
 
-@TestTargetClass(PipedReader.class) 
-public class PipedReaderTest extends junit.framework.TestCase {
+import junit.framework.TestCase;
+
+public class PipedReaderTest extends TestCase {
 
     static class PWriter implements Runnable {
         public PipedWriter pw;
@@ -57,29 +53,6 @@
         }
     }
 
-    static class PWriter2 implements Runnable {
-        PipedWriter pw;
-
-        public boolean keepRunning = true;
-
-        public void run() {
-            try {
-                pw.write('H');
-                pw.close();
-                while (keepRunning) {
-                    Thread.sleep(1000);
-                }
-            } catch (Exception e) {
-                e.printStackTrace(System.out);
-                System.out.println("Error while running the writer thread.");
-            }
-        }
-
-        public PWriter2(PipedWriter writer) {
-            pw = writer;
-        }
-    }
-    
     PipedReader preader;
 
     PWriter pwriter;
@@ -89,88 +62,80 @@
     /**
      * @tests java.io.PipedReader#PipedReader()
      */
-    @TestTargetNew(
-        level = TestLevel.COMPLETE,
-        notes = "",
-        method = "PipedReader",
-        args = {}
-    )
     public void test_Constructor() {
-        preader = new PipedReader();
-        assertNotNull(preader);
-        try {
-            preader.close();
-        } catch (IOException e) {
-            fail("Unexpeceted IOException");
-        }
+        // Used in test
     }
 
     /**
      * @tests java.io.PipedReader#PipedReader(java.io.PipedWriter)
      */
-    @TestTargetNew(
-        level = TestLevel.COMPLETE,
-        notes = "",
-        method = "PipedReader",
-        args = {java.io.PipedWriter.class}
-    )
     public void test_ConstructorLjava_io_PipedWriter() throws IOException {
-        // Test for method java.io.PipedReader(java.io.PipedWriter)
+        preader = new PipedReader(new PipedWriter());
+    }
+    
+    /**
+     * @tests java.io.PipedReader#PipedReader(java.io.PipedWriter,
+     *        int)
+     * @since 1.6
+     */
+    public void test_Constructor_LPipedWriter_I() throws Exception {
+        // Test for method java.io.PipedReader(java.io.PipedWriter,
+        // int)
         try {
-            preader = new PipedReader(new PipedWriter());
-        } catch (Exception e) {
-            fail("Test 1: Constructor failed: " + e.getMessage());
+            preader = new PipedReader(null, -1);
+            fail("Should throw IllegalArgumentException"); //$NON-NLS-1$
+        } catch (IllegalArgumentException e) {
+            // expected
         }
-        preader.close();
-            
-        PipedWriter pw = new PipedWriter(new PipedReader());
+        
         try {
-            preader = new PipedReader(pw);
-            fail("Test 2: IOException expected because the writer is already connected.");
-        } catch (IOException e) {
-            // Expected.
+            preader = new PipedReader(null, 0);
+            fail("Should throw IllegalArgumentException"); //$NON-NLS-1$
+        } catch (IllegalArgumentException e) {
+            // expected
+        }
+    }
+
+    /**
+     * @tests java.io.PipedReader#PipedReader(int)
+     * @since 1.6
+     */
+    public void test_Constructor_I() throws Exception {
+        // Test for method java.io.PipedReader(int)
+        try {
+            preader = new PipedReader(-1);
+            fail("Should throw IllegalArgumentException"); //$NON-NLS-1$
+        } catch (IllegalArgumentException e) {
+            // expected
+        }
+        
+        try {
+            preader = new PipedReader(0);
+            fail("Should throw IllegalArgumentException"); //$NON-NLS-1$
+        } catch (IllegalArgumentException e) {
+            // expected
         }
     }
 
     /**
      * @tests java.io.PipedReader#close()
      */
-    @TestTargetNew(
-        level = TestLevel.COMPLETE,
-        notes = "No IOException checking because it is never thrown in the source code.",
-        method = "close",
-        args = {}
-    )
     public void test_close() throws Exception {
-        // Test for method void java.io.PipedReader.close()
         char[] c = null;
         preader = new PipedReader();
         t = new Thread(new PWriter(preader), "");
         t.start();
         Thread.sleep(500); // Allow writer to start
         c = new char[11];
-        preader.read(c, 0, 5);
+        preader.read(c, 0, 11);
         preader.close();
-        
-        try {
-            preader.read(c, 0, 5);
-            fail("IOException expected because the reader is closed.");
-        } catch (IOException e) {
-            // Expected.
-        }
+        assertEquals("Read incorrect chars", "Hello World", new String(c));
     }
 
     /**
      * @tests java.io.PipedReader#connect(java.io.PipedWriter)
      */
-    @TestTargetNew(
-        level = TestLevel.COMPLETE,
-        notes = "",
-        method = "connect",
-        args = {java.io.PipedWriter.class}
-    )
     public void test_connectLjava_io_PipedWriter() throws Exception {
-        // Test for method void java.io.PipedReader.connect(java.io.PipedWriter)
         char[] c = null;
 
         preader = new PipedReader();
@@ -181,26 +146,19 @@
         c = new char[11];
         preader.read(c, 0, 11);
 
-        assertEquals("Test 1: Wrong characters read. ", "Hello World", new String(c));
+        assertEquals("Read incorrect chars", "Hello World", new String(c));
         try {
-            preader.connect(new PipedWriter());
-            fail("Test 2: IOException expected because the reader is already connected.");
+            preader.connect(pwriter.pw);
+            fail("Failed to throw exception connecting to pre-connected reader");
         } catch (IOException e) {
-            // Expected.
+            // Expected
         }
     }
 
     /**
      * @tests java.io.PipedReader#read()
      */
-    @TestTargetNew(
-        level = TestLevel.PARTIAL_COMPLETE,
-        notes = "",
-        method = "read",
-        args = {}
-    )
-    public void test_read_1() throws Exception {
-        // Test for method int java.io.PipedReader.read()
+    public void test_read() throws Exception {
         char[] c = null;
         preader = new PipedReader();
         t = new Thread(new PWriter(preader), "");
@@ -210,62 +168,13 @@
         for (int i = 0; i < c.length; i++) {
             c[i] = (char) preader.read();
         }
-        assertEquals("Test 1: Wrong characters read. ", "Hello World", new String(c));
-        
-        try {
-            preader.read();
-            fail("Test 2: IOException expected since the thread that has " +
-                 "written to the pipe is no longer alive.");
-        } catch (IOException e) {
-            // Expected.
-        }
-        
-        preader.close();
-        try {
-            preader.read();
-            fail("Test 3: IOException expected.");
-        } catch (IOException e) {
-            // Expected.
-        }
-    }
-
-    /**
-     * @tests java.io.PipedReader#read()
-     */
-    @TestTargetNew(
-        level = TestLevel.PARTIAL_COMPLETE,
-        notes = "Checks that read() returns -1 if the PipedWriter connectedto this PipedReader is closed.",
-        method = "read",
-        args = {}
-    )
-    public void test_read_2() throws Exception {
-        Thread writerThread;
-        PipedWriter pw;
-        PWriter2 pwriter;
-
-        preader = new PipedReader();
-        pw = new PipedWriter(preader);
-        
-        writerThread = new Thread(pwriter = new PWriter2(pw), "PWriter2");
-        writerThread.start();
-        Thread.sleep(500); // Allow writer to start
-        
-        preader.read();
-        assertEquals("Test 1: No more data indication expected. ", -1, preader.read());
-        pwriter.keepRunning = false;
+        assertEquals("Read incorrect chars", "Hello World", new String(c));
     }
 
     /**
      * @tests java.io.PipedReader#read(char[], int, int)
      */
-    @TestTargetNew(
-        level = TestLevel.PARTIAL_COMPLETE,
-        notes = "IOException checking missed.",
-        method = "read",
-        args = {char[].class, int.class, int.class}
-    )
-    public void test_read$CII_1() throws Exception {
-        // Test for method int java.io.PipedReader.read(char [], int, int)
+    public void test_read$CII() throws Exception {
         char[] c = null;
         preader = new PipedReader();
         t = new Thread(new PWriter(preader), "");
@@ -278,121 +187,231 @@
             n = preader.read(c, x, 11 - x);
             x = x + n;
         }
-        assertEquals("Test 1: Wrong characters read. ", "Hello World", new String(c));
-
-        preader.close();
+        assertEquals("Read incorrect chars", "Hello World", new String(c));
         try {
+            preader.close();
             preader.read(c, 8, 7);
-            fail("Test 2: IOException expected.");
+            fail("Failed to throw exception reading from closed reader");
         } catch (IOException e) {
-            // Expected.
+            // Expected
         }
     }
 
     /**
      * @tests java.io.PipedReader#read(char[], int, int)
      */
-    @TestTargetNew(
-        level = TestLevel.PARTIAL_COMPLETE,
-        notes = "",
-        method = "read",
-        args = {char[].class, int.class, int.class}
-    )
-    public void test_read$CII_Exception() throws IOException{
+    public void test_read$CII_2() throws IOException {
+        // Regression for HARMONY-387
         PipedWriter pw = new PipedWriter();
-        PipedReader obj = new PipedReader(pw);
+        PipedReader obj = null;
         try {
-            obj.read(new char[10], 0, -1);
-            fail("IndexOutOfBoundsException expected.");
-        } catch (IndexOutOfBoundsException e) {
-            // Expected.
-        }
-        try {
-            obj.read(new char[10], -1, 1);
-            fail("IndexOutOfBoundsException expected.");
-        } catch (IndexOutOfBoundsException e) {
-            // Expected.
-        }
-        try {
-            obj.read(new char[10], 2, 9);
-            fail("IndexOutOfBoundsException expected.");
-        } catch (IndexOutOfBoundsException e) {
-            // Expected.
-        }
-        try {
-            obj.read(null, 0, 1);
-            fail("NullPointerException expected.");
-        } catch (NullPointerException e) {
-            // Expected.
+            obj = new PipedReader(pw);
+            obj.read(new char[0], (int) 0, (int) -1);
+            fail("IndexOutOfBoundsException expected");
+        } catch (IndexOutOfBoundsException t) {
+            assertEquals(
+                    "IndexOutOfBoundsException rather than a subclass expected",
+                    IndexOutOfBoundsException.class, t.getClass());
         }
     }
 
     /**
-     * @tests java.io.PipedReader#read()
+     * @tests java.io.PipedReader#read(char[], int, int)
      */
-    @TestTargetNew(
-        level = TestLevel.PARTIAL_COMPLETE,
-        notes = "Checks that read() returns -1 if the PipedWriter connectedto this PipedReader is closed.",
-        method = "read",
-        args = {}
-    )
-    public void test_read$CII_2() throws Exception {
-        Thread writerThread;
-        PipedWriter pw;
-        PWriter2 pwriter;
-        char[] c = new char[1];
+    public void test_read$CII_3() throws IOException {
+        PipedWriter pw = new PipedWriter();
+        PipedReader obj = null;
+        try {
+            obj = new PipedReader(pw);
+            obj.read(new char[0], (int) -1, (int) 0);
+            fail("IndexOutOfBoundsException expected");
+        } catch (ArrayIndexOutOfBoundsException t) {
+            fail("IndexOutOfBoundsException expected");
+        } catch (IndexOutOfBoundsException t) {
+            // Expected
+        }
+    }
 
-        preader = new PipedReader();
-        pw = new PipedWriter(preader);
-        
-        writerThread = new Thread(pwriter = new PWriter2(pw), "PWriter2");
-        writerThread.start();
-        Thread.sleep(500); // Allow writer to start
-        
-        preader.read(c, 0, 1);
-        assertEquals("Test 1: No more data indication expected. ", 
-                     -1, preader.read(c, 0, 1));
-        pwriter.keepRunning = false;
+    /**
+     * @tests java.io.PipedReader#read(char[], int, int)
+     */
+    public void test_read$CII_4() throws IOException {
+        PipedWriter pw = new PipedWriter();
+        PipedReader obj = null;
+        try {
+            obj = new PipedReader(pw);
+            obj.read(new char[0], (int) -1, (int) -1);
+            fail("IndexOutOfBoundsException expected");
+        } catch (ArrayIndexOutOfBoundsException t) {
+            fail("IndexOutOfBoundsException expected");
+        } catch (IndexOutOfBoundsException t) {
+            // Expected
+        }
+    }
+
+    /**
+     * @tests java.io.PipedReader#read(char[], int, int)
+     */
+    public void test_read_$CII_IOException() throws IOException {
+        PipedWriter pw = new PipedWriter();
+        PipedReader pr = new PipedReader(pw);
+        char[] buf = null;
+        pr.close();
+        try {
+            pr.read(buf, 0, 10);
+            fail("Should throws IOException"); //$NON-NLS-1$
+        } catch (IOException e) {
+            // expected
+        } finally {
+            pw = null;
+            pr = null;
+        }
+
+        pr = new PipedReader();
+        buf = null;
+        pr.close();
+        try {
+            pr.read(buf, 0, 10);
+            fail("Should throws IOException"); //$NON-NLS-1$
+        } catch (IOException e) {
+            // expected
+        } finally {
+            pr = null;
+        }
+
+        pw = new PipedWriter();
+        pr = new PipedReader(pw);
+        buf = new char[10];
+        pr.close();
+        try {
+            pr.read(buf, -1, 0);
+            fail("Should throws IOException"); //$NON-NLS-1$
+        } catch (IOException e) {
+            // expected
+        } finally {
+            pw = null;
+            pr = null;
+        }
+
+        pw = new PipedWriter();
+        pr = new PipedReader(pw);
+        buf = new char[10];
+        pr.close();
+        try {
+            pr.read(buf, 0, -1);
+            fail("Should throws IOException"); //$NON-NLS-1$
+        } catch (IOException e) {
+            // expected
+        } finally {
+            pw = null;
+            pr = null;
+        }
+
+        pw = new PipedWriter();
+        pr = new PipedReader(pw);
+        buf = new char[10];
+        pr.close();
+        try {
+            pr.read(buf, 1, 10);
+            fail("Should throws IOException"); //$NON-NLS-1$
+        } catch (IOException e) {
+            // expected
+        } finally {
+            pw = null;
+            pr = null;
+        }
+
+        pw = new PipedWriter();
+        pr = new PipedReader(pw);
+        pr.close();
+        try {
+            pr.read(new char[0], -1, -1);
+            fail("should throw IOException"); //$NON-NLS-1$
+        } catch (IOException e) {
+            // expected
+        } finally {
+            pw = null;
+            pr = null;
+        }
+
+        pw = new PipedWriter();
+        pr = new PipedReader(pw);
+        pr.close();
+        try {
+            pr.read(null, 0, 1);
+            fail("should throw IOException"); //$NON-NLS-1$
+        } catch (IOException e) {
+            // expected
+        } finally {
+            pw = null;
+            pr = null;
+        }
+
+        pw = new PipedWriter();
+        pr = new PipedReader(pw);
+        try {
+            pr.read(null, -1, 1);
+            fail("should throw IndexOutOfBoundsException"); //$NON-NLS-1$
+        } catch (NullPointerException expected) { // android-added
+        } catch (IndexOutOfBoundsException e) {
+            // expected
+        } finally {
+            pw = null;
+            pr = null;
+        }
+
+        pw = new PipedWriter();
+        pr = new PipedReader(pw);
+        try {
+            pr.read(null, 0, -1);
+            fail("should throw NullPointerException"); //$NON-NLS-1$
+        } catch (NullPointerException e) {
+            // expected
+        } finally {
+            pw = null;
+            pr = null;
+        }
+
+        pw = new PipedWriter();
+        pr = new PipedReader(pw);
+        try {
+            pr.read(new char[10], 11, 0);
+            fail("should throw IndexOutOfBoundsException"); //$NON-NLS-1$
+        } catch (IndexOutOfBoundsException e) {
+            // expected
+        } finally {
+            pw = null;
+            pr = null;
+        }
+
+        pw = new PipedWriter();
+        pr = new PipedReader(pw);
+        try {
+            pr.read(null, 1, 0);
+            fail("should throw NullPointerException"); //$NON-NLS-1$
+        } catch (NullPointerException e) {
+            // expected
+        } finally {
+            pw = null;
+            pr = null;
+        }
     }
 
     /**
      * @tests java.io.PipedReader#ready()
      */
-    @TestTargetNew(
-        level = TestLevel.COMPLETE,
-        notes = "",
-        method = "ready",
-        args = {}
-    )
     public void test_ready() throws Exception {
-        // Test for method boolean java.io.PipedReader.ready()
         char[] c = null;
         preader = new PipedReader();
-        
-        try {
-            preader.ready();
-            fail("Test 1: IOException expected.");
-        } catch (IOException e) {
-            // Expected.
-        }
-        
         t = new Thread(new PWriter(preader), "");
         t.start();
         Thread.sleep(500); // Allow writer to start
-        assertTrue("Test 2: Reader should be ready", preader.ready());
+        assertTrue("Reader should be ready", preader.ready());
         c = new char[11];
         for (int i = 0; i < c.length; i++)
             c[i] = (char) preader.read();
-        assertFalse("Test 3: Reader should not be ready after reading all chars",
+        assertFalse("Reader should not be ready after reading all chars",
                 preader.ready());
-        
-        preader.close();
-        try {
-            preader.ready();
-            fail("Test 4: IOException expected.");
-        } catch (IOException e) {
-            // Expected.
-        }
     }
 
     /**