| /* |
| * 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.InputStream; |
| import java.io.IOException; |
| import java.io.ObjectInput; |
| |
| @TestTargetClass(InputStream.class) |
| public class InputStreamTest extends junit.framework.TestCase { |
| |
| public 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"; |
| |
| private InputStream is; |
| |
| class MockInputStream extends java.io.InputStream { |
| |
| private byte[] input; |
| private int position; |
| |
| public MockInputStream() { |
| super(); |
| input = testString.getBytes(); |
| position = 0; |
| } |
| |
| public int read() throws IOException { |
| int result = -1; |
| if (position < input.length) { |
| result = input[position]; |
| position++; |
| } |
| return result; |
| } |
| } |
| |
| /** |
| * @tests java.io.InputStream#InputStream() |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "Verifies constructor InputStream(). Since this constructor does nothing, this test is intentionally kept basic.", |
| method = "InputStream", |
| args = {} |
| ) |
| public void test_Constructor() { |
| try { |
| InputStream myIS = new MockInputStream(); |
| myIS.close(); |
| } catch (Exception e) { |
| fail("Unexpected exception: " + e.getMessage()); |
| } |
| } |
| |
| /** |
| * @tests java.io.InputStream#available() |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "Verifies that available() returns 0.", |
| method = "available", |
| args = {} |
| ) |
| public void test_available() throws IOException { |
| assertEquals(is.available(), 0); |
| } |
| |
| /** |
| * @tests java.io.InputStream#close() |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "Verifies close(). Since this method does nothing, this test is intentionally kept basic.", |
| method = "close", |
| args = {} |
| ) |
| public void test_close() { |
| try { |
| is.close(); |
| } catch (Exception e) { |
| fail("Unexpected exception: " + e.getMessage()); |
| } |
| } |
| |
| /** |
| * @tests java.io.InputStream#mark(int) |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "Verifies mark(int). Since this method does nothing, this test is intentionally kept basic.", |
| method = "mark", |
| args = {int.class} |
| ) |
| public void test_markI() { |
| try { |
| is.mark(10); |
| } catch (Exception e) { |
| fail("Unexpected exception: " + e.getMessage()); |
| } |
| } |
| |
| /** |
| * @tests java.io.InputStream#markSupported() |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "Verifies that markSupported() returns false.", |
| method = "markSupported", |
| args = {} |
| ) |
| public void test_markSupported() throws IOException { |
| assertFalse("markSupported() has returned the wrong default value.", |
| is.markSupported()); |
| } |
| |
| /** |
| * @tests java.io.InputStream#read(byte[]) |
| */ |
| @TestTargets ( |
| { @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "Verifies read(byte[]).", |
| method = "read", |
| args = {byte[].class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "Verifies ObjectInput.read(byte[]) since " + |
| "ObjectInputStream inherits the implementation " + |
| "of read(byte[]) from InputStream.", |
| clazz = ObjectInput.class, |
| method = "read", |
| args = {byte[].class} |
| ) |
| } |
| |
| ) |
| public void test_read$B() throws IOException { |
| byte[] b = new byte[10]; |
| byte[] ref = testString.getBytes(); |
| boolean equal = true; |
| int bytesRead = 0; |
| int i; |
| |
| // Test 1: This read operation should complete without an error. |
| assertEquals("Test 1: Incorrect count of bytes read.", |
| is.read(b), 10); |
| |
| for (i = 0; i < 10; i++) { |
| equal &= (b[i] == ref[i]); |
| } |
| assertTrue("Test 1: Wrong bytes read.", equal); |
| |
| // Test 2: Test that the correct number of bytes read is returned |
| // if the source has less bytes available than fit in the buffer. |
| b = new byte[ref.length]; |
| bytesRead = is.read(b); |
| assertEquals("Test 2: Incorrect count of bytes read.", |
| bytesRead, ref.length - 10); |
| |
| for (i = 0; i < bytesRead; i++) { |
| equal &= (b[i] == ref[i + 10]); |
| } |
| assertTrue("Test 2: Wrong bytes read.", equal); |
| |
| // Test 3: Since we have now reached the end of the source, |
| // the next call of read(byte[]) should return -1. |
| bytesRead = is.read(b); |
| assertEquals("Test 3:", bytesRead, -1); |
| } |
| |
| /** |
| * @tests java.io.InputStream#read(byte[], int, int) |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL, |
| notes = "Verifies argument checking of read(byte[], int, int).", |
| method = "read", |
| args = {byte[].class, int.class, int.class} |
| ) |
| public void test_read$BII_Exception() throws IOException { |
| byte[] b = new byte[10]; |
| int bytesRead = 0; |
| |
| // Test 1: Invalid offset. |
| try { |
| bytesRead = is.read(b, -1, 5); |
| fail("Test 1: IndexOutOfBoundsException expected."); |
| } catch (IndexOutOfBoundsException e) { |
| // expected |
| } |
| |
| // Test 2: Invalid length. |
| try { |
| bytesRead = is.read(b, 5, -1); |
| fail("Test 2: IndexOutOfBoundsException expected."); |
| } catch (IndexOutOfBoundsException e) { |
| // expected |
| } |
| |
| // Test 3: Invalid offset and length combination (sum is larger |
| // than the length of b). |
| try { |
| bytesRead = is.read(b, 6, 5); |
| fail("Test 3: IndexOutOfBoundsException expected."); |
| } catch (IndexOutOfBoundsException e) { |
| // expected |
| } |
| |
| // Test 4: Border case. |
| try { |
| bytesRead = is.read(b, 6, 4); |
| } catch (IndexOutOfBoundsException e) { |
| fail("Test 4: Unexpected IndexOutOfBoundsException."); |
| } |
| assertEquals("Test 4:", bytesRead, 4); |
| |
| // Test 5: Border case. |
| try { |
| bytesRead = is.read(b, 6, 0); |
| } catch (Exception e) { |
| fail("Test 5: Unexpected Exception " + e.getMessage()); |
| } |
| assertEquals("Test 5:", bytesRead, 0); |
| } |
| |
| /** |
| * @tests java.io.InputStream#read(byte[], int, int) |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "Verifies read(byte[], int, int).", |
| method = "read", |
| args = {byte[].class, int.class, int.class} |
| ) |
| public void test_read$BII() throws IOException { |
| byte[] b = new byte[10]; |
| byte[] ref = testString.getBytes(); |
| boolean equal = true; |
| int bytesRead = 0; |
| int i; |
| |
| // Test 1: This read operation should complete without an error. |
| assertEquals("Test 1: Incorrect count of bytes read.", |
| is.read(b, 0, 5), 5); |
| |
| for (i = 0; i < 5; i++) { |
| equal &= (b[i] == ref[i]); |
| } |
| assertTrue("Test 1: Wrong bytes read.", equal); |
| |
| // Test 2: Read operation with offset. |
| assertEquals("Test 2: Incorrect count of bytes read.", |
| is.read(b, 5, 3), 3); |
| |
| for (i = 5; i < 8; i++) { |
| equal &= (b[i] == ref[i]); |
| } |
| assertTrue("Test 2: Wrong bytes read.", equal); |
| |
| // Test 3: Test that the correct number of bytes read is returned |
| // if the source has less bytes available than fit in the buffer. |
| b = new byte[ref.length]; |
| bytesRead = is.read(b, 2, b.length - 2); |
| |
| // 8 bytes have been read during tests 1 and 2. |
| assertEquals("Test 3: Incorrect count of bytes read.", |
| bytesRead, ref.length - 8); |
| |
| // The first two bytes of b should be 0 because of the offset. |
| assertEquals("Test 3:", b[0], 0); |
| assertEquals("Test 3:", b[1], 0); |
| for (i = 0; i < bytesRead; i++) { |
| equal &= (b[i + 2] == ref[i + 8]); |
| } |
| assertTrue("Test 2: Wrong bytes read.", equal); |
| |
| // Test 4: Since we have now reached the end of the source, |
| // the next call of read(byte[], int, int) should return -1. |
| assertEquals("Test 4:", is.read(b, 0, 2), -1); |
| } |
| |
| /** |
| * @tests java.io.InputStream#reset() |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "Verifies that reset() throws an IOException.", |
| method = "reset", |
| args = {} |
| ) |
| public void test_reset() { |
| try { |
| is.reset(); |
| fail("IOException expected."); |
| } catch (IOException e) { |
| // expected |
| } |
| } |
| |
| /** |
| * @tests java.io.InputStream#skip(long) |
| */ |
| @TestTargets ( |
| { @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "Verifies skip(long).", |
| method = "skip", |
| args = {long.class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "Verifies ObjectInput.skip(long) since " + |
| "ObjectInputStream inherits the implementation " + |
| "of skip(long) from InputStream.", |
| clazz = ObjectInput.class, |
| method = "skip", |
| args = {long.class} |
| ) |
| } |
| ) |
| public void test_skipL() throws IOException { |
| byte[] b = new byte[12]; |
| byte[] ref = testString.getBytes(); |
| int i; |
| boolean equal = true; |
| |
| // Test 1: Check that skip(long) just returns 0 if called with a |
| // negative number. |
| assertEquals("Test 1:", is.skip(-42), 0); |
| assertEquals("Test 1: Incorrect count of bytes read.", |
| is.read(b), 12); |
| for (i = 0; i < 12; i++) { |
| equal &= (b[i] == ref[i]); |
| } |
| assertTrue("Test 1: Wrong bytes read.", equal); |
| |
| // Test 2: Check if the number of bytes skipped matches the requested |
| // number of bytes to skip. |
| assertEquals("Test 2: Incorrect count of bytes skipped.", |
| is.skip(17), 17); |
| |
| // Test 3: Check that bytes have actually been skipped |
| is.read(b, 0, 10); |
| for (i = 0; i < 10; i++) { |
| equal &= (b[i] == ref[i + 29]); |
| } |
| assertTrue("Test 3: Wrong bytes read.", equal); |
| |
| // Test 4: Test that the correct number of bytes skipped is returned |
| // if the source has less bytes available than fit in the buffer. |
| assertEquals("Test 4: Incorrect count of bytes skipped.", |
| is.skip(ref.length), ref.length - 39); |
| |
| // Test 5: Since we have now reached the end of the source, |
| // the next call of read(byte[]) should return -1 and calling |
| // skip(long) should return 0. |
| assertEquals("Test 5:", is.read(b), -1); |
| assertEquals("Test 5:", is.skip(10), 0); |
| } |
| |
| /** |
| * This method is called before a test is executed. It creates a |
| * MockInputStream instance. |
| */ |
| protected void setUp() { |
| is = new MockInputStream(); |
| } |
| |
| /** |
| * This method is called after a test is executed. It closes the |
| * MockInputStream instance. |
| */ |
| protected void tearDown() { |
| try { |
| is.close(); |
| } catch (Exception e) { |
| } |
| } |
| } |