mirror of
https://github.com/Eaglercraft-TeaVM-Fork/eagler-teavm.git
synced 2024-12-22 08:14:09 -08:00
Add PipedInputStream and PipedOutputStream
This commit is contained in:
Alexey Andreev
parent
82b96da215
commit
0e5b1a97c1
|
|
@ -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);
|
||||
}
|
||||
}
|
||||
|
|
@ -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();
|
||||
}
|
||||
}
|
||||
|
|
@ -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);
|
||||
}
|
||||
}
|
||||
|
|
@ -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;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -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();
|
||||
}
|
||||
}
|
||||
}
|
||||
Loading…
Reference in New Issue
Block a user