From 0e5b1a97c19f2a273ac571f7f1cbf1dd578bc502 Mon Sep 17 00:00:00 2001 From: Alexey Andreev Date: Thu, 16 Nov 2017 13:44:21 +0300 Subject: [PATCH] Add PipedInputStream and PipedOutputStream --- .../java/io/TInterruptedIOException.java | 31 ++ .../classlib/java/io/TPipedInputStream.java | 244 +++++++++++ .../classlib/java/io/TPipedOutputStream.java | 81 ++++ .../org/teavm/classlib/java/lang/TThread.java | 6 + .../java/io/PipedInputStreamTest.java | 397 ++++++++++++++++++ .../java/io/PipedOutputStreamTest.java | 169 ++++++++ 6 files changed, 928 insertions(+) create mode 100644 classlib/src/main/java/org/teavm/classlib/java/io/TInterruptedIOException.java create mode 100644 classlib/src/main/java/org/teavm/classlib/java/io/TPipedInputStream.java create mode 100644 classlib/src/main/java/org/teavm/classlib/java/io/TPipedOutputStream.java create mode 100644 tests/src/test/java/org/teavm/classlib/java/io/PipedInputStreamTest.java create mode 100644 tests/src/test/java/org/teavm/classlib/java/io/PipedOutputStreamTest.java diff --git a/classlib/src/main/java/org/teavm/classlib/java/io/TInterruptedIOException.java b/classlib/src/main/java/org/teavm/classlib/java/io/TInterruptedIOException.java new file mode 100644 index 000000000..82a8fca99 --- /dev/null +++ b/classlib/src/main/java/org/teavm/classlib/java/io/TInterruptedIOException.java @@ -0,0 +1,31 @@ +/* + * Copyright 2017 Alexey Andreev. + * + * 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 org.teavm.classlib.java.io; + +import java.io.IOException; + +public class TInterruptedIOException extends IOException { + public int bytesTransferred; + + public TInterruptedIOException() { + super(); + } + + public TInterruptedIOException(String detailMessage) { + super(detailMessage); + } +} diff --git a/classlib/src/main/java/org/teavm/classlib/java/io/TPipedInputStream.java b/classlib/src/main/java/org/teavm/classlib/java/io/TPipedInputStream.java new file mode 100644 index 000000000..bb1ea0b14 --- /dev/null +++ b/classlib/src/main/java/org/teavm/classlib/java/io/TPipedInputStream.java @@ -0,0 +1,244 @@ +/* + * Copyright 2017 Alexey Andreev. + * + * 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 org.teavm.classlib.java.io; + +import java.io.IOException; +import java.io.InputStream; +import java.io.InterruptedIOException; + +public class TPipedInputStream extends InputStream { + private Thread lastReader; + private Thread lastWriter; + private boolean isClosed; + + protected byte[] buffer; + protected int in = -1; + protected int out; + protected static final int PIPE_SIZE = 1024; + + boolean isConnected; + + public TPipedInputStream() { + /* empty */ + } + public TPipedInputStream(TPipedOutputStream out) throws IOException { + connect(out); + } + + @Override + public int available() throws IOException { + if (buffer == null || in == -1) { + return 0; + } + return in <= out ? buffer.length - out + in : in - out; + } + + @Override + public void close() throws IOException { + /* No exception thrown if already closed */ + if (buffer != null) { + /* Release buffer to indicate closed. */ + buffer = null; + } + } + + public void connect(TPipedOutputStream src) throws IOException { + src.connect(this); + } + + @Override + public synchronized int read() throws IOException { + if (!isConnected) { + throw new IOException("Not connected"); + } + if (buffer == null) { + throw new IOException("InputStream is closed"); + } + + if (isClosed && in == -1) { + // write end closed and no more need to read + return -1; + } + + if (lastWriter != null && !lastWriter.isAlive() && in < 0) { + throw new IOException("Write end dead"); + } + /* + * Set the last thread to be reading on this PipedInputStream. If + * lastReader dies while someone is waiting to write an IOException of + * "Pipe broken" will be thrown in receive() + */ + lastReader = Thread.currentThread(); + try { + int attempts = 3; + while (in == -1) { + // Are we at end of stream? + if (isClosed) { + return -1; + } + if ((attempts-- <= 0) && lastWriter != null && !lastWriter.isAlive()) { + throw new IOException("Pipe broken"); + } + // Notify callers of receive() + notifyAll(); + wait(1000); + } + } catch (InterruptedException e) { + throw new InterruptedIOException(); + } + + byte result = buffer[out++]; + if (out == buffer.length) { + out = 0; + } + if (out == in) { + // empty buffer + in = -1; + out = 0; + } + return result & 0xff; + } + + @Override + public synchronized int read(byte[] bytes, int offset, int count) throws IOException { + if (bytes == null) { + throw new NullPointerException(); + } + + if (offset < 0 || offset > bytes.length || count < 0 + || count > bytes.length - offset) { + throw new IndexOutOfBoundsException(); + } + + if (count == 0) { + return 0; + } + + if (isClosed && in == -1) { + // write end closed and no more need to read + return -1; + } + + if (!isConnected) { + throw new IOException("Not connected"); + } + + if (buffer == null) { + throw new IOException("InputStream is closed"); + } + + if (lastWriter != null && !lastWriter.isAlive() && (in < 0)) { + throw new IOException("Write end dead"); + } + + /* + * Set the last thread to be reading on this PipedInputStream. If + * lastReader dies while someone is waiting to write an IOException of + * "Pipe broken" will be thrown in receive() + */ + lastReader = Thread.currentThread(); + try { + int attempts = 3; + while (in == -1) { + // Are we at end of stream? + if (isClosed) { + return -1; + } + if ((attempts-- <= 0) && lastWriter != null && !lastWriter.isAlive()) { + throw new IOException("Pipe broken"); + } + // Notify callers of receive() + notifyAll(); + wait(1000); + } + } catch (InterruptedException e) { + throw new InterruptedIOException(); + } + + int copyLength = 0; + /* Copy bytes from out to end of buffer first */ + if (out >= in) { + copyLength = count > (buffer.length - out) ? buffer.length - out : count; + System.arraycopy(buffer, out, bytes, offset, copyLength); + out += copyLength; + if (out == buffer.length) { + out = 0; + } + if (out == in) { + // empty buffer + in = -1; + out = 0; + } + } + + if (copyLength == count || in == -1) { + return copyLength; + } + + int bytesCopied = copyLength; + /* Copy bytes from 0 to the number of available bytes */ + copyLength = in - out > (count - bytesCopied) ? count - bytesCopied : in - out; + System.arraycopy(buffer, out, bytes, offset + bytesCopied, copyLength); + out += copyLength; + if (out == in) { + // empty buffer + in = -1; + out = 0; + } + return bytesCopied + copyLength; + } + + protected synchronized void receive(int oneByte) throws IOException { + if (buffer == null || isClosed) { + throw new IOException(); + } + if (lastReader != null && !lastReader.isAlive()) { + throw new IOException(); + } + /* + * Set the last thread to be writing on this PipedInputStream. If + * lastWriter dies while someone is waiting to read an IOException of + * "Pipe broken" will be thrown in read() + */ + lastWriter = Thread.currentThread(); + try { + while (buffer != null && out == in) { + notifyAll(); + wait(1000); + if (lastReader != null && !lastReader.isAlive()) { + throw new IOException(); + } + } + } catch (InterruptedException e) { + throw new InterruptedIOException(); + } + if (buffer != null) { + if (in == -1) { + in = 0; + } + buffer[in++] = (byte) oneByte; + if (in == buffer.length) { + in = 0; + } + } + } + + synchronized void done() { + isClosed = true; + notifyAll(); + } +} diff --git a/classlib/src/main/java/org/teavm/classlib/java/io/TPipedOutputStream.java b/classlib/src/main/java/org/teavm/classlib/java/io/TPipedOutputStream.java new file mode 100644 index 000000000..3b9d6f843 --- /dev/null +++ b/classlib/src/main/java/org/teavm/classlib/java/io/TPipedOutputStream.java @@ -0,0 +1,81 @@ +/* + * Copyright 2017 Alexey Andreev. + * + * 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 org.teavm.classlib.java.io; + +import java.io.IOException; +import java.io.OutputStream; + +public class TPipedOutputStream extends OutputStream { + private TPipedInputStream dest; + + public TPipedOutputStream() { + super(); + } + + public TPipedOutputStream(TPipedInputStream dest) throws IOException { + super(); + connect(dest); + } + + @Override + public void close() throws IOException { + // Is the pipe connected? + if (dest != null) { + dest.done(); + dest = null; + } + } + + public void connect(TPipedInputStream stream) throws IOException { + if (null == stream) { + throw new NullPointerException(); + } + if (this.dest != null) { + throw new IOException(); + } + synchronized (stream) { + if (stream.isConnected) { + throw new IOException(); + } + stream.buffer = new byte[TPipedInputStream.PIPE_SIZE]; + stream.isConnected = true; + this.dest = stream; + } + } + + @Override + public void flush() throws IOException { + if (dest != null) { + synchronized (dest) { + dest.notifyAll(); + } + } + } + + @Override + public void write(byte[] buffer, int offset, int count) throws IOException { + super.write(buffer, offset, count); + } + + @Override + public void write(int oneByte) throws IOException { + if (dest == null) { + throw new IOException(); + } + dest.receive(oneByte); + } +} diff --git a/classlib/src/main/java/org/teavm/classlib/java/lang/TThread.java b/classlib/src/main/java/org/teavm/classlib/java/lang/TThread.java index 0c950a23d..038df91a4 100644 --- a/classlib/src/main/java/org/teavm/classlib/java/lang/TThread.java +++ b/classlib/src/main/java/org/teavm/classlib/java/lang/TThread.java @@ -34,6 +34,7 @@ public class TThread extends TObject implements TRunnable { private TThreadInterruptHandler interruptHandler; private TString name; + private boolean alive = true; TRunnable target; public TThread() { @@ -61,6 +62,7 @@ public class TThread extends TObject implements TRunnable { setCurrentThread(TThread.this); TThread.this.run(); } finally { + alive = false; activeCount--; setCurrentThread(mainThread); } @@ -153,6 +155,10 @@ public class TThread extends TObject implements TRunnable { return interruptedFlag; } + public boolean isAlive() { + return alive; + } + public static int activeCount() { return activeCount; } diff --git a/tests/src/test/java/org/teavm/classlib/java/io/PipedInputStreamTest.java b/tests/src/test/java/org/teavm/classlib/java/io/PipedInputStreamTest.java new file mode 100644 index 000000000..4bb0ae672 --- /dev/null +++ b/tests/src/test/java/org/teavm/classlib/java/io/PipedInputStreamTest.java @@ -0,0 +1,397 @@ +/* + * Copyright 2017 Alexey Andreev. + * + * 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 org.teavm.classlib.java.io; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; +import static org.junit.Assert.fail; +import java.io.IOException; +import java.io.PipedInputStream; +import java.io.PipedOutputStream; +import org.junit.After; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.teavm.junit.TeaVMTestRunner; + +@RunWith(TeaVMTestRunner.class) +public class PipedInputStreamTest { + static class PWriter implements Runnable { + PipedOutputStream pos; + + public byte[] bytes; + + @Override + public void run() { + try { + pos.write(bytes); + synchronized (this) { + notify(); + } + } catch (IOException e) { + e.printStackTrace(System.out); + System.out.println("Could not write bytes"); + } + } + + 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); + } + } + } + + private Thread t; + private PWriter pw; + private PipedInputStream pis; + private PipedOutputStream pos; + + @Test + public void constructor() { + // Used in tests + } + + @Test + public void constructorLjava_io_PipedOutputStream() throws IOException { + pis = new PipedInputStream(new PipedOutputStream()); + pis.available(); + } + + //@Test + // TODO: fix and uncomment + public void readException() throws IOException { + pis = new PipedInputStream(); + pos = new PipedOutputStream(); + + try { + pis.connect(pos); + pw = new PWriter(pos, 1000); + t = new Thread(pw); + t.start(); + assertTrue(t.isAlive()); + while (true) { + pis.read(); + t.interrupt(); + } + } catch (IOException e) { + if (!e.getMessage().contains("Write end dead")) { + throw e; + } + } finally { + try { + pis.close(); + pos.close(); + } catch (IOException ee) { + // Do nothing + } + } + } + + @Test + public void available() throws Exception { + pis = new PipedInputStream(); + pos = new PipedOutputStream(); + + pis.connect(pos); + pw = new PWriter(pos, 1000); + t = new Thread(pw); + t.start(); + + synchronized (pw) { + pw.wait(10000); + } + 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++) { + pout.write(i); + } + assertEquals("Incorrect available count", 1024, pin.available()); + } + + @Test + public void close() throws IOException { + pis = new PipedInputStream(); + pos = new PipedOutputStream(); + pis.connect(pos); + pis.close(); + 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 + } + } + + @Test + public void connectLjava_io_PipedOutputStream() throws Exception { + pis = new PipedInputStream(); + pos = new PipedOutputStream(); + assertEquals("Non-conected pipe returned non-zero available bytes", 0, pis.available()); + + pis.connect(pos); + pw = new PWriter(pos, 1000); + t = new Thread(pw); + t.start(); + + synchronized (pw) { + pw.wait(10000); + } + assertEquals("Available returned incorrect number of bytes", 1000, pis.available()); + } + + @Test + public void test_read() throws Exception { + pis = new PipedInputStream(); + pos = new PipedOutputStream(); + + pis.connect(pos); + pw = new PWriter(pos, 1000); + t = new Thread(pw); + t.start(); + + synchronized (pw) { + pw.wait(10000); + } + assertEquals("Available returned incorrect number of bytes", 1000, pis.available()); + assertEquals("read returned incorrect byte", pw.bytes[0], (byte) pis.read()); + } + + @Test + public void test_read$BII() throws Exception { + pis = new PipedInputStream(); + pos = new PipedOutputStream(); + + pis.connect(pos); + pw = new PWriter(pos, 1000); + t = new Thread(pw); + t.start(); + + byte[] buf = new byte[400]; + synchronized (pw) { + pw.wait(10000); + } + 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("read returned incorrect byte[]", pw.bytes[i], buf[i]); + } + } + + @Test + public void read$BII_2() throws IOException { + PipedInputStream obj = new PipedInputStream(); + try { + obj.read(new byte[0], 0, -1); + fail("IndexOutOfBoundsException expected"); + } catch (IndexOutOfBoundsException t) { + assertEquals( + "IndexOutOfBoundsException rather than a subclass expected", + IndexOutOfBoundsException.class, t.getClass()); + } + } + + @Test + public void read$BII_3() throws IOException { + PipedInputStream obj = new PipedInputStream(); + try { + obj.read(new byte[0], -1, 0); + fail("IndexOutOfBoundsException expected"); + } catch (ArrayIndexOutOfBoundsException t) { + fail("IndexOutOfBoundsException expected"); + } catch (IndexOutOfBoundsException t) { + // Do nothing + } + } + + @Test + public void read$BII_4() throws IOException { + PipedInputStream obj = new PipedInputStream(); + try { + obj.read(new byte[0], -1, -1); + fail("IndexOutOfBoundsException expected"); + } catch (ArrayIndexOutOfBoundsException t) { + fail("IndexOutOfBoundsException expected"); + } catch (IndexOutOfBoundsException t) { + // Do nothing + } + } + + //@Test + // TODO: fix + public void receive() throws IOException { + pis = new PipedInputStream(); + pos = new PipedOutputStream(); + + // test if writer recognizes dead reader + pis.connect(pos); + class WriteRunnable implements Runnable { + + private boolean pass; + + private volatile boolean readerAlive = true; + + @Override + public void run() { + try { + pos.write(1); + while (readerAlive) { + // Do nothing + } + try { + // should throw exception since reader thread + // is now dead + pos.write(1); + } catch (IOException e) { + pass = true; + } + } catch (IOException e) { + // Do nothing + } + } + } + WriteRunnable writeRunnable = new WriteRunnable(); + Thread writeThread = new Thread(writeRunnable); + class ReadRunnable implements Runnable { + + private boolean pass; + + @Override + public void run() { + try { + pis.read(); + pass = true; + } catch (IOException e) { + // Do nothing + } + } + } + + ReadRunnable readRunnable = new ReadRunnable(); + Thread readThread = new Thread(readRunnable); + writeThread.start(); + readThread.start(); + while (readThread.isAlive()) { + // Do nothing + } + writeRunnable.readerAlive = false; + assertTrue("reader thread failed to read", readRunnable.pass); + while (writeThread.isAlive()) { + // Do nothing + } + assertTrue("writer thread failed to recognize dead reader", writeRunnable.pass); + + // attempt to write to stream after writer closed + pis = new PipedInputStream(); + pos = new PipedOutputStream(); + + pis.connect(pos); + class MyRunnable implements Runnable { + + private boolean pass; + + @Override + public void run() { + try { + pos.write(1); + } catch (IOException e) { + pass = true; + } + } + } + MyRunnable myRun = new MyRunnable(); + synchronized (pis) { + t = new Thread(myRun); + // thread t will be blocked inside pos.write(1) + // when it tries to call the synchronized method pis.receive + // because we hold the monitor for object pis + t.start(); + try { + // wait for thread t to get to the call to pis.receive + Thread.sleep(100); + } catch (InterruptedException e) { + // Do nothing + } + // now we close + pos.close(); + } + // we have exited the synchronized block, so now thread t will make + // a call to pis.receive AFTER the output stream was closed, + // in which case an IOException should be thrown + while (t.isAlive()) { + // Do nothing + } + assertTrue( + "write failed to throw IOException on closed PipedOutputStream", + myRun.pass); + } + + static class Worker extends Thread { + PipedOutputStream out; + + Worker(PipedOutputStream pos) { + this.out = pos; + } + + @Override + public void run() { + try { + out.write(20); + out.close(); + Thread.sleep(5000); + } catch (Exception e) { + // Do nothing + } + } + } + + @Test + public void read_after_write_close() throws Exception { + PipedInputStream in = new PipedInputStream(); + PipedOutputStream out = new PipedOutputStream(); + in.connect(out); + Thread worker = new Worker(out); + worker.start(); + Thread.sleep(2000); + assertEquals("Should read 20.", 20, in.read()); + worker.join(); + assertEquals("Write end is closed, should return -1", -1, in.read()); + byte[] buf = new byte[1]; + assertEquals("Write end is closed, should return -1", -1, in.read(buf, 0, 1)); + assertEquals("Buf len 0 should return first", 0, in.read(buf, 0, 0)); + in.close(); + out.close(); + } + + @After + public void tearDown() { + try { + if (t != null) { + t.interrupt(); + } + } catch (Exception ignore) { + // Do nothing + } + } +} diff --git a/tests/src/test/java/org/teavm/classlib/java/io/PipedOutputStreamTest.java b/tests/src/test/java/org/teavm/classlib/java/io/PipedOutputStreamTest.java new file mode 100644 index 000000000..3c680bb69 --- /dev/null +++ b/tests/src/test/java/org/teavm/classlib/java/io/PipedOutputStreamTest.java @@ -0,0 +1,169 @@ +/* + * Copyright 2017 Alexey Andreev. + * + * 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 org.teavm.classlib.java.io; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; +import static org.junit.Assert.fail; +import java.io.IOException; +import java.io.PipedInputStream; +import java.io.PipedOutputStream; +import org.junit.After; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.teavm.junit.TeaVMTestRunner; + +@RunWith(TeaVMTestRunner.class) +public class PipedOutputStreamTest { + static class PReader implements Runnable { + PipedInputStream reader; + + public PipedInputStream getReader() { + return reader; + } + + PReader(PipedOutputStream out) { + try { + reader = new PipedInputStream(out); + } catch (Exception e) { + System.out.println("Couldn't start reader"); + } + } + + public int available() { + try { + return reader.available(); + } catch (Exception e) { + return -1; + } + } + + @Override + public void run() { + try { + while (true) { + Thread.sleep(1000); + Thread.yield(); + } + } catch (InterruptedException e) { + // Do nothing + } + } + + public String read(int nbytes) { + byte[] buf = new byte[nbytes]; + try { + reader.read(buf, 0, nbytes); + return new String(buf, "UTF-8"); + } catch (IOException e) { + System.out.println("Exception reading info"); + return "ERROR"; + } + } + } + + private Thread rt; + private PReader reader; + private PipedOutputStream out; + + @Test + public void constructor() { + // Used in tests + } + + @Test + public void constructorLjava_io_PipedInputStream() throws Exception { + out = new PipedOutputStream(new PipedInputStream()); + out.write('b'); + } + + @Test + public void close() throws Exception { + out = new PipedOutputStream(); + reader = new PReader(out); + rt = new Thread(reader); + rt.start(); + out.close(); + } + + @Test + public void connectLjava_io_PipedInputStream_Exception() throws IOException { + out = new PipedOutputStream(); + out.connect(new PipedInputStream()); + try { + out.connect(null); + fail("should throw NullPointerException"); //$NON-NLS-1$ + } catch (NullPointerException e) { + // expected + } + } + + @Test + public void connectLjava_io_PipedInputStream() { + try { + out = new PipedOutputStream(); + reader = new PReader(out); + rt = new Thread(reader); + rt.start(); + out.connect(new PipedInputStream()); + fail("Failed to throw exception attempting connect on already connected stream"); + } catch (IOException e) { + // Expected + } + } + + @Test + public void flush() throws IOException { + out = new PipedOutputStream(); + reader = new PReader(out); + rt = new Thread(reader); + rt.start(); + out.write("HelloWorld".getBytes("UTF-8"), 0, 10); + assertTrue("Bytes written before flush", reader.available() != 0); + out.flush(); + assertEquals("Wrote incorrect bytes", "HelloWorld", reader.read(10)); + } + + @Test + public void write$BII() throws IOException { + out = new PipedOutputStream(); + reader = new PReader(out); + rt = new Thread(reader); + rt.start(); + out.write("HelloWorld".getBytes("UTF-8"), 0, 10); + out.flush(); + assertEquals("Wrote incorrect bytes", "HelloWorld", reader.read(10)); + } + + @Test + public void test_writeI() throws IOException { + out = new PipedOutputStream(); + reader = new PReader(out); + rt = new Thread(reader); + rt.start(); + out.write('c'); + out.flush(); + assertEquals("Wrote incorrect byte", "c", reader.read(1)); + } + + @After + public void tearDown() { + if (rt != null) { + rt.interrupt(); + } + } +}