| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package 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.PipedInputStream; |
| import java.io.PipedOutputStream; |
| |
| @TestTargetClass(PipedOutputStream.class) |
| public class PipedOutputStreamTest extends junit.framework.TestCase { |
| |
| static class PReader implements Runnable { |
| PipedInputStream reader; |
| |
| public PipedInputStream getReader() { |
| return reader; |
| } |
| |
| public PReader(PipedOutputStream out) { |
| try { |
| reader = new PipedInputStream(out); |
| } catch (Exception e) { |
| System.out.println("Exception setting up reader: " |
| + e.toString()); |
| } |
| } |
| |
| public int available() { |
| try { |
| return reader.available(); |
| } catch (Exception e) { |
| return -1; |
| } |
| } |
| |
| public void run() { |
| try { |
| while (true) { |
| Thread.sleep(1000); |
| Thread.yield(); |
| } |
| } catch (InterruptedException e) { |
| } |
| } |
| |
| public String read(int nbytes) { |
| byte[] buf = new byte[nbytes]; |
| try { |
| reader.read(buf, 0, nbytes); |
| return new String(buf); |
| } catch (IOException e) { |
| System.out.println("Exception reading (" |
| + Thread.currentThread().getName() + "): " |
| + e.toString()); |
| return "ERROR"; |
| } |
| } |
| } |
| |
| static final String testString = "Lorem ipsum dolor sit amet,\n" + |
| "consectetur adipisicing elit,\nsed do eiusmod tempor incididunt ut" + |
| "labore et dolore magna aliqua.\n"; |
| static final int testLength = testString.length(); |
| |
| Thread rt; |
| |
| PReader reader; |
| |
| PipedOutputStream out; |
| |
| /** |
| * @tests java.io.PipedOutputStream#PipedOutputStream() |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "PipedOutputStream", |
| args = {} |
| ) |
| public void test_Constructor() { |
| out = new PipedOutputStream(); |
| assertNotNull(out); |
| try { |
| out.close(); |
| } catch (IOException e) { |
| fail("Unexpeceted IOException."); |
| } |
| } |
| |
| /** |
| * @tests java.io.PipedOutputStream#PipedOutputStream(java.io.PipedInputStream) |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "PipedOutputStream", |
| args = {java.io.PipedInputStream.class} |
| ) |
| public void test_ConstructorLjava_io_PipedInputStream() throws IOException { |
| // Test for method java.io.PipedOutputStream(java.io.PipedInputStream) |
| |
| try { |
| out = new PipedOutputStream(new PipedInputStream()); |
| out.write('b'); |
| } catch (Exception e) { |
| fail("Test 1: Constructor failed: " + e.getMessage()); |
| } |
| out.close(); |
| |
| PipedInputStream pis = new PipedInputStream(new PipedOutputStream()); |
| try { |
| out = new PipedOutputStream(pis); |
| fail("Test 2: IOException expected because the input stream is already connected."); |
| } catch (IOException e) { |
| // Expected. |
| } |
| } |
| |
| /** |
| * @tests java.io.PipedOutputStream#close() |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "close", |
| args = {} |
| ) |
| public void test_close() { |
| out = new PipedOutputStream(); |
| rt = new Thread(reader = new PReader(out)); |
| rt.start(); |
| try { |
| out.close(); |
| } catch (IOException e) { |
| fail("Test 1: Unexpected IOException: " + e.getMessage()); |
| } |
| } |
| |
| /** |
| * @tests java.io.PipedOutputStream#connect(java.io.PipedInputStream) |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "connect", |
| args = {java.io.PipedInputStream.class} |
| ) |
| public void test_connectLjava_io_PipedInputStream() throws IOException { |
| out = new PipedOutputStream(); |
| |
| try { |
| out.connect(new PipedInputStream()); |
| } catch (Exception e) { |
| fail("Test 1: Unexpected exception when connecting: " + |
| e.getLocalizedMessage()); |
| } |
| |
| try { |
| out.write('B'); |
| } catch (IOException e) { |
| fail("Test 2: Unexpected IOException when writing after connecting."); |
| } |
| |
| try { |
| out.connect(new PipedInputStream()); |
| fail("Test 3: IOException expected when reconnecting the stream."); |
| } catch (IOException e) { |
| // Expected. |
| } |
| |
| try { |
| out.connect(null); |
| fail("Test 4: NullPointerException expected."); |
| } catch (NullPointerException e) { |
| // Expected. |
| } |
| } |
| |
| /** |
| * @tests java.io.PipedOutputStream#flush() |
| */ |
| @TestTargetNew( |
| level = TestLevel.SUFFICIENT, |
| notes = "No IOException checking because it is never thrown in the source code.", |
| method = "flush", |
| args = {} |
| ) |
| public void test_flush() throws Exception { |
| out = new PipedOutputStream(); |
| rt = new Thread(reader = new PReader(out)); |
| rt.start(); |
| out.write(testString.getBytes(), 0, 10); |
| assertTrue("Test 1: Bytes have been written before flush.", reader.available() != 0); |
| out.flush(); |
| assertEquals("Test 2: Flush failed. ", |
| testString.substring(0, 10), reader.read(10)); |
| } |
| |
| /** |
| * @tests java.io.PipedOutputStream#write(byte[], int, int) |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "Test 6 disabled due to incomplete implementation, see ticket #92.", |
| method = "write", |
| args = {byte[].class, int.class, int.class} |
| ) |
| public void test_write$BII() throws IOException { |
| out = new PipedOutputStream(); |
| |
| try { |
| out.write(testString.getBytes(), 0, 5); |
| fail("Test 1: IOException expected."); |
| } catch (IOException e) { |
| // Expected. |
| } |
| |
| out = new PipedOutputStream(new PipedInputStream()); |
| |
| try { |
| out.write(testString.getBytes(), -1, 10); |
| fail("Test 2: IndexOutOfBoundsException expected."); |
| } catch (IndexOutOfBoundsException e) { |
| // Expected. |
| } |
| |
| try { |
| out.write(testString.getBytes(), 0, -1); |
| fail("Test 3: IndexOutOfBoundsException expected."); |
| } catch (IndexOutOfBoundsException e) { |
| // Expected. |
| } |
| |
| try { |
| out.write(testString.getBytes(), 5, testString.length()); |
| fail("Test 4: IndexOutOfBoundsException expected."); |
| } catch (IndexOutOfBoundsException e) { |
| // Expected. |
| } |
| |
| out.close(); |
| out = new PipedOutputStream(); |
| try { |
| rt = new Thread(reader = new PReader(out)); |
| rt.start(); |
| out.write(testString.getBytes(), 0, testString.length()); |
| out.flush(); |
| assertEquals("Test 5: Bytes read do not match the bytes written. ", |
| testString, reader.read(testString.length())); |
| } catch (IOException e) { |
| fail("Test 5: Unexpected IOException: " + e.getMessage()); |
| } |
| |
| reader.getReader().close(); |
| try { |
| out.write(testString.getBytes(), 0, 5); |
| fail("Test 7: IOException expected."); |
| } catch (IOException e) { |
| // Expected. |
| } |
| } |
| |
| |
| /** |
| * @tests java.io.PipedOutputStream#write(int) |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "Test 3 disabled due to incomplete implementation, see ticket #92.", |
| method = "write", |
| args = {int.class} |
| ) |
| public void test_writeI() throws IOException { |
| out = new PipedOutputStream(); |
| |
| try { |
| out.write(42); |
| fail("Test 1: IOException expected."); |
| } catch (IOException e) { |
| // Expected. |
| } |
| |
| rt = new Thread(reader = new PReader(out)); |
| rt.start(); |
| out.write('c'); |
| out.flush(); |
| assertEquals("Test 2: The byte read does not match the byte written. ", |
| "c", reader.read(1)); |
| |
| /* Test disabled due to incomplete implementation, see ticket #92. |
| rt.interrupt(); |
| |
| try { |
| out.write(42); |
| fail("Test 3: IOException expected."); |
| } catch (IOException e) { |
| // Expected. |
| } |
| } |
| */ |
| reader.getReader().close(); |
| try { |
| out.write(42); |
| fail("Test 4: IOException expected."); |
| } catch (IOException e) { |
| // Expected. |
| } |
| } |
| |
| /** |
| * Tears down the fixture, for example, close a network connection. This |
| * method is called after a test is executed. |
| */ |
| protected void tearDown() throws Exception { |
| if (rt != null) |
| rt.interrupt(); |
| super.tearDown(); |
| } |
| } |