| /* |
| * 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 java.io.CharArrayReader; |
| import java.io.FilterReader; |
| import java.io.IOException; |
| import java.io.PushbackReader; |
| import java.io.Reader; |
| import java.io.StringReader; |
| |
| import tests.support.Support_ASimpleReader; |
| import dalvik.annotation.TestLevel; |
| import dalvik.annotation.TestTargetClass; |
| import dalvik.annotation.TestTargetNew; |
| |
| @TestTargetClass(PushbackReader.class) |
| public class PushbackReaderTest extends junit.framework.TestCase { |
| |
| Support_ASimpleReader underlying = new Support_ASimpleReader(); |
| PushbackReader pbr; |
| |
| String pbString = "Hello World"; |
| |
| /** |
| * @tests java.io.PushbackReader#PushbackReader(java.io.Reader) |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| method = "PushbackReader", |
| args = {java.io.Reader.class} |
| ) |
| public void test_ConstructorLjava_io_Reader() { |
| // Test for method java.io.PushbackReader(java.io.Reader) |
| try { |
| pbr.close(); |
| pbr = new PushbackReader(new StringReader(pbString)); |
| char buf[] = new char[5]; |
| pbr.read(buf, 0, 5); |
| pbr.unread(buf); |
| fail("Created reader with buffer larger than 1");; |
| } catch (IOException e) { |
| // Expected |
| } |
| |
| try { |
| pbr = new PushbackReader(null); |
| } catch (NullPointerException e) { |
| // EXpected |
| } |
| } |
| |
| /** |
| * @throws IOException |
| * @tests java.io.PushbackReader#PushbackReader(java.io.Reader, int) |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| method = "PushbackReader", |
| args = {java.io.Reader.class, int.class} |
| ) |
| public void test_ConstructorLjava_io_ReaderI() throws IOException { |
| PushbackReader tobj; |
| |
| tobj = new PushbackReader(underlying, 10000); |
| tobj = new PushbackReader(underlying, 1); |
| |
| try { |
| tobj = new PushbackReader(underlying, -1); |
| tobj.close(); |
| fail("IOException not thrown."); |
| } catch (IllegalArgumentException e) { |
| // expected |
| } |
| try { |
| tobj = new PushbackReader(underlying, 0); |
| tobj.close(); |
| fail("IOException not thrown."); |
| } catch (IllegalArgumentException e) { |
| // expected |
| } |
| } |
| |
| /** |
| * @throws IOException |
| * @tests java.io.PushbackReader#close() |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| method = "close", |
| args = {} |
| ) |
| public void test_close() throws IOException { |
| PushbackReader tobj; |
| |
| tobj = new PushbackReader(underlying); |
| tobj.close(); |
| tobj.close(); |
| tobj = new PushbackReader(underlying); |
| underlying.throwExceptionOnNextUse = true; |
| try { |
| tobj.close(); |
| fail("IOException not thrown."); |
| } catch (IOException e) { |
| // expected |
| } |
| |
| // Test for method void java.io.PushbackReader.close() |
| try { |
| pbr.close(); |
| pbr.read(); |
| } catch (Exception e) { |
| return; |
| } |
| fail("Failed to throw exception reading from closed reader"); |
| |
| } |
| |
| /** |
| * @tests java.io.PushbackReader#mark(int) |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| method = "mark", |
| args = {int.class} |
| ) |
| public void test_markI() { |
| try { |
| pbr.mark(3); |
| fail("Test 1: IOException expected because marking is not supported."); |
| } catch (IOException e) { |
| // Expected. |
| } |
| } |
| |
| /** |
| * @tests java.io.PushbackReader#markSupported() |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| method = "markSupported", |
| args = {} |
| ) |
| public void test_markSupported() { |
| assertFalse("Test 1: markSupported() must return false.", |
| pbr.markSupported()); |
| } |
| |
| /** |
| * @throws IOException |
| * @tests java.io.PushbackReader#read() |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| method = "read", |
| args = {} |
| ) |
| public void test_read() throws IOException { |
| PushbackReader tobj; |
| |
| tobj = new PushbackReader(underlying); |
| assertEquals("Wrong value read!", 66, tobj.read()); |
| underlying.throwExceptionOnNextUse = true; |
| try { |
| tobj.read(); |
| fail("IOException not thrown."); |
| } catch (IOException e) { |
| // expected |
| } |
| |
| // Test for method int java.io.PushbackReader.read() |
| try { |
| char c; |
| pbr.read(); |
| c = (char) pbr.read(); |
| assertTrue("Failed to read char: " + c, c == pbString.charAt(1)); |
| Reader reader = new PushbackReader(new CharArrayReader( |
| new char[] { '\u8765' })); |
| assertTrue("Wrong double byte character", reader.read() == '\u8765'); |
| } catch (IOException e) { |
| fail("IOException during read test : " + e.getMessage()); |
| } |
| } |
| |
| /** |
| * @throws IOException |
| * @tests java.io.PushbackReader#read(char[], int, int) |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| method = "read", |
| args = {char[].class, int.class, int.class} |
| ) |
| public void test_read$CII() throws IOException { |
| PushbackReader tobj; |
| char[] buf = ("01234567890123456789").toCharArray(); |
| |
| tobj = new PushbackReader(underlying); |
| tobj.read(buf, 6, 5); |
| assertEquals("Wrong value read!", "BEGIN", new String(buf, 6, 5)); |
| assertEquals("Too much read!", "012345BEGIN123456789", new String(buf)); |
| underlying.throwExceptionOnNextUse = true; |
| try { |
| tobj.read(buf, 6, 5); |
| fail("IOException not thrown."); |
| } catch (IOException e) { |
| // expected |
| } |
| |
| // Test for method int java.io.PushbackReader.read(char [], int, int) |
| try { |
| char[] c = new char[5]; |
| pbr.read(c, 0, 5); |
| assertTrue("Failed to read chars", new String(c).equals(pbString |
| .substring(0, 5))); |
| |
| assertEquals(0, pbr.read(c, 0, 0)); |
| assertEquals(c.length, pbr.read(c, 0, c.length)); |
| assertEquals(0, pbr.read(c, c.length, 0)); |
| } catch (IOException e) { |
| fail("IOException during read test : " + e.getMessage()); |
| } |
| } |
| |
| /** |
| * @tests java.io.PushbackReader#read(char[], int, int) |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Checks exceptions.", |
| method = "read", |
| args = {char[].class, int.class, int.class} |
| ) |
| public void test_read_$CII_Exception() throws IOException { |
| pbr = new PushbackReader(new StringReader(pbString), 10); |
| |
| char[] nullCharArray = null; |
| char[] charArray = new char[10]; |
| |
| try { |
| pbr.read(nullCharArray, 0, 1); |
| fail("should throw NullPointerException"); |
| } catch (NullPointerException e) { |
| // expected |
| } |
| |
| try { |
| pbr.read(charArray, 0, -1); |
| fail("should throw IndexOutOfBoundsException"); |
| } catch (IndexOutOfBoundsException e) { |
| // expected |
| } |
| |
| try { |
| pbr.read(charArray, -1, 0); |
| fail("should throw IndexOutOfBoundsException"); |
| } catch (IndexOutOfBoundsException e) { |
| // expected |
| } |
| |
| try { |
| pbr.read(charArray, charArray.length + 1, 0); |
| fail("should throw IndexOutOfBoundsException"); |
| } catch (IndexOutOfBoundsException e) { |
| // expected |
| } |
| |
| try { |
| pbr.read(charArray, charArray.length, 1); |
| fail("should throw IndexOutOfBoundsException"); |
| } catch (IndexOutOfBoundsException e) { |
| // expected |
| } |
| |
| try { |
| pbr.read(charArray, 1, charArray.length); |
| fail("should throw IndexOutOfBoundsException"); |
| } catch (IndexOutOfBoundsException e) { |
| // expected |
| } |
| |
| try { |
| pbr.read(charArray, 0, charArray.length + 1); |
| fail("should throw IndexOutOfBoundsException"); |
| } catch (IndexOutOfBoundsException e) { |
| // expected |
| } |
| |
| pbr.close(); |
| |
| try { |
| pbr.read(charArray, 0, 1); |
| fail("should throw IOException"); |
| } catch (IOException e) { |
| // expected |
| } |
| } |
| |
| /** |
| * @throws IOException |
| * @tests java.io.PushbackReader#ready() |
| */ |
| @TestTargetNew( |
| level = TestLevel.SUFFICIENT, |
| notes = "Could also add tests where underlying says no but push back buffer has contents.", |
| method = "ready", |
| args = {} |
| ) |
| public void test_ready() throws IOException { |
| PushbackReader tobj; |
| |
| tobj = new PushbackReader(underlying); |
| assertTrue("Should be ready!", tobj.ready()); |
| underlying.throwExceptionOnNextUse = true; |
| try { |
| tobj.ready(); |
| fail("IOException not thrown."); |
| } catch (IOException e) { |
| // expected |
| } |
| |
| // Test for method boolean java.io.PushbackReader.ready() |
| try { |
| char[] c = new char[11]; |
| if (c.length > 0) |
| ;// use c to avoid warning msg |
| assertTrue("Ready stream returned false to ready()", pbr.ready()); |
| } catch (IOException e) { |
| fail("IOException during ready() test : " + e.getMessage()); |
| } |
| } |
| |
| /** |
| * @tests java.io.PushbackReader#reset() |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| method = "reset", |
| args = {} |
| ) |
| public void test_reset() { |
| try { |
| pbr.reset(); |
| } catch (IOException e) { |
| // correct |
| return; |
| } |
| fail("reset failed to throw expected IOException"); |
| } |
| |
| /** |
| * @throws IOException |
| * @tests java.io.PushbackReader#unread(char[]) |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| method = "unread", |
| args = {char[].class} |
| ) |
| public void test_unread$C() throws IOException { |
| PushbackReader tobj; |
| String str2 = "0123456789"; |
| char[] buf2 = str2.toCharArray(); |
| char[] readBuf = new char[10]; |
| |
| tobj = new PushbackReader(underlying, 10); |
| tobj.unread(buf2); |
| try { |
| tobj.unread(buf2); |
| fail("IOException not thrown."); |
| } catch (IOException e) { |
| // expected |
| } |
| tobj.read(readBuf); |
| assertEquals("Incorrect bytes read", str2, new String(readBuf)); |
| underlying.throwExceptionOnNextUse = true; |
| try { |
| tobj.read(buf2); |
| fail("IOException not thrown."); |
| } catch (IOException e) { |
| // expected |
| } |
| |
| // Test for method void java.io.PushbackReader.unread(char []) |
| try { |
| char[] c = new char[5]; |
| pbr.read(c, 0, 5); |
| pbr.unread(c); |
| pbr.read(c, 0, 5); |
| assertTrue("Failed to unread chars", new String(c).equals(pbString |
| .substring(0, 5))); |
| } catch (IOException e) { |
| fail("IOException during read test : " + e.getMessage()); |
| } |
| } |
| |
| /** |
| * @throws IOException |
| * @tests java.io.PushbackReader#skip(long) |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| method = "skip", |
| args = {long.class} |
| ) |
| public void test_skip$J() throws IOException { |
| PushbackReader tobj; |
| |
| tobj = new PushbackReader(underlying); |
| tobj.skip(6); |
| tobj.skip(1000000); |
| tobj.skip(1000000); |
| underlying.throwExceptionOnNextUse = true; |
| try { |
| tobj.skip(1); |
| fail("IOException not thrown."); |
| } catch (IOException e) { |
| // expected |
| } |
| |
| char chars[] = new char[] { 'h', 'e', 'l', 'l', 'o' }; |
| for (int i = 0; i < 3; i++) { |
| Reader reader, reader2; |
| switch (i) { |
| case 0: |
| reader = new StringReader(new String(chars)); |
| reader2 = new StringReader(new String(chars)); |
| break; |
| case 1: |
| reader = new FilterReader(new StringReader(new String(chars))) { |
| }; |
| reader2 = new FilterReader(new StringReader(new String(chars))) { |
| }; |
| break; |
| default: |
| reader = new CharArrayReader(chars); |
| reader2 = new CharArrayReader(chars); |
| } |
| PushbackReader pReader = new PushbackReader(reader, 2); |
| PushbackReader pReader2 = new PushbackReader(reader2, 2); |
| boolean skipped = false; |
| long numSkipped = 0; |
| try { |
| numSkipped = pReader2.skip(3); |
| pReader2.unread('a'); |
| pReader2.unread('b'); |
| numSkipped += pReader2.skip(10); |
| numSkipped += pReader2.skip(10); |
| numSkipped += pReader2.skip(10); |
| numSkipped += pReader2.skip(10); |
| numSkipped += pReader2.skip(10); |
| numSkipped += pReader2.skip(10); |
| assertEquals("Did not skip correct number of characters", |
| 7, numSkipped); |
| numSkipped = 0; |
| numSkipped += pReader.skip(2); |
| pReader.unread('i'); |
| numSkipped += pReader.skip(2); |
| numSkipped += pReader.skip(0); |
| skipped = true; |
| numSkipped += pReader.skip(-1); |
| fail("Failed to throw " |
| + new IllegalArgumentException().getClass().getName()); |
| } catch (IllegalArgumentException e) { |
| assertTrue("Failed to skip characters" + e, skipped); |
| } catch (IOException e) { |
| fail("Failed to skip characters" + e); |
| } |
| try { |
| numSkipped += pReader.skip(1); |
| numSkipped += pReader.skip(1); |
| numSkipped += pReader.skip(1); |
| assertEquals("Failed to skip all characters", 6, numSkipped); |
| long nextSkipped = pReader.skip(1); |
| assertEquals("skipped empty reader", 0, nextSkipped); |
| } catch (IOException e) { |
| fail("Failed to skip more characters" + e); |
| } |
| } |
| } |
| |
| /** |
| * @throws IOException |
| * @tests java.io.PushbackReader#unread(char[], int, int) |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| method = "unread", |
| args = {char[].class, int.class, int.class} |
| ) |
| public void test_unread$CII() throws IOException { |
| PushbackReader tobj; |
| String str2 = "0123456789"; |
| char[] buf2 = (str2 + str2 + str2).toCharArray(); |
| char[] readBuf = new char[10]; |
| |
| tobj = new PushbackReader(underlying, 10); |
| tobj.unread(buf2, 15, 10); |
| try { |
| tobj.unread(buf2, 15, 10); |
| fail("IOException not thrown."); |
| } catch (IOException e) { |
| // expected |
| } |
| tobj.read(readBuf); |
| assertEquals("Incorrect bytes read", "5678901234", new String(readBuf)); |
| underlying.throwExceptionOnNextUse = true; |
| try { |
| tobj.read(buf2, 15, 10); |
| fail("IOException not thrown."); |
| } catch (IOException e) { |
| // expected |
| } |
| |
| // Test for method void java.io.PushbackReader.unread(char [], int, int) |
| try { |
| char[] c = new char[5]; |
| pbr.read(c, 0, 5); |
| pbr.unread(c, 0, 2); |
| pbr.read(c, 0, 5); |
| assertTrue("Failed to unread chars", new String(c).equals(pbString |
| .substring(0, 2) |
| + pbString.substring(5, 8))); |
| } catch (IOException e) { |
| fail("IOException during unread test : " + e.getMessage()); |
| } |
| } |
| |
| /** |
| * @tests java.io.PushbackReader#unread(char[], int, int) |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| method = "unread", |
| args = {char[].class, int.class, int.class} |
| ) |
| public void test_unread_$CII_NullPointerException() throws IOException { |
| //a pushback reader with one character buffer |
| pbr = new PushbackReader(new StringReader(pbString)); |
| |
| try { |
| pbr.unread(null, 0, 1); |
| fail("should throw NullPointerException"); |
| } catch (NullPointerException e) { |
| // expected |
| } |
| } |
| |
| /** |
| * @tests java.io.PushbackReader#unread(char[], int, int) |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| method = "unread", |
| args = {char[].class, int.class, int.class} |
| ) |
| public void test_unread_$CII_Exception_InsufficientBuffer() throws IOException { |
| //a pushback reader with one character buffer |
| pbr = new PushbackReader(new StringReader(pbString)); |
| |
| //if count > buffer's size , should throw IOException |
| try { |
| pbr.unread(new char[pbString.length()], 0, 2); |
| fail("should throw IOException"); |
| } catch (IOException e) { |
| // expected |
| } |
| } |
| |
| /** |
| * @tests java.io.PushbackReader#unread(char[], int, int) |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| method = "unread", |
| args = {char[].class, int.class, int.class} |
| ) |
| public void test_unread_$CII_ArrayIndexOutOfBoundsException() throws IOException { |
| //a pushback reader with one character buffer |
| pbr = new PushbackReader(new StringReader(pbString)); |
| |
| try { |
| pbr.unread(new char[pbString.length()], -1 , 1); |
| fail("should throw ArrayIndexOutOfBoundsException"); |
| } catch (IndexOutOfBoundsException e) { |
| // expected |
| } |
| try { |
| pbr.unread(new char[pbString.length()], 0 , -1); |
| fail("should throw ArrayIndexOutOfBoundsException"); |
| } catch (IndexOutOfBoundsException e) { |
| // expected |
| } |
| try { |
| pbr.unread(new char[10], 10 , 1); |
| fail("should throw ArrayIndexOutOfBoundsException"); |
| } catch (IndexOutOfBoundsException e) { |
| // expected |
| } |
| } |
| |
| /** |
| * @throws IOException |
| * @tests java.io.PushbackReader#unread(int) |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "unread", |
| args = {int.class} |
| ) |
| public void test_unreadI() throws IOException { |
| PushbackReader tobj; |
| |
| tobj = new PushbackReader(underlying); |
| tobj.unread(23); // Why does this work?!? |
| tobj.skip(2); |
| tobj.unread(23); |
| assertEquals("Wrong value read!", 23, tobj.read()); |
| tobj.unread(13); |
| try { |
| tobj.unread(13); |
| fail("IOException not thrown (ACTUALLY NOT SURE WHETHER IT REALLY MUST BE THROWN!)."); |
| } catch (IOException e) { |
| // expected |
| } |
| |
| // Test for method void java.io.PushbackReader.unread(int) |
| try { |
| int c; |
| pbr.read(); |
| c = pbr.read(); |
| pbr.unread(c); |
| assertTrue("Failed to unread char", pbr.read() == c); |
| } catch (IOException e) { |
| fail("IOException during unread test : " + e.getMessage()); |
| } |
| } |
| |
| /** |
| * Sets up the fixture, for example, open a network connection. This method |
| * is called before a test is executed. |
| */ |
| protected void setUp() { |
| pbr = new PushbackReader(new StringReader(pbString), 10); |
| } |
| |
| /** |
| * Tears down the fixture, for example, close a network connection. This |
| * method is called after a test is executed. |
| */ |
| protected void tearDown() { |
| try { |
| pbr.close(); |
| } catch (IOException e) { |
| } |
| } |
| } |