| /* |
| * 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 libcore.java.io; |
| |
| import java.io.IOException; |
| import java.io.PushbackReader; |
| import java.io.StringReader; |
| import tests.support.Support_ASimpleReader; |
| |
| public class OldPushbackReaderTest extends junit.framework.TestCase { |
| |
| Support_ASimpleReader underlying = new Support_ASimpleReader(); |
| PushbackReader pbr; |
| |
| String pbString = "Hello World"; |
| |
| /** |
| * java.io.PushbackReader#PushbackReader(java.io.Reader) |
| */ |
| 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 |
| } |
| } |
| |
| /** |
| * java.io.PushbackReader#PushbackReader(java.io.Reader, int) |
| */ |
| 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 |
| } |
| } |
| |
| /** |
| * java.io.PushbackReader#close() |
| */ |
| 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 |
| } |
| } |
| |
| /** |
| * java.io.PushbackReader#markSupported() |
| */ |
| public void test_markSupported() { |
| assertFalse("Test 1: markSupported() must return false.", |
| pbr.markSupported()); |
| } |
| |
| /** |
| * java.io.PushbackReader#read() |
| */ |
| 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 |
| } |
| } |
| |
| /** |
| * java.io.PushbackReader#read(char[], int, int) |
| */ |
| 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()); |
| } |
| } |
| |
| /** |
| * java.io.PushbackReader#read(char[], int, int) |
| */ |
| 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 |
| } |
| } |
| |
| /** |
| * java.io.PushbackReader#ready() |
| */ |
| 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 |
| } |
| } |
| /** |
| * java.io.PushbackReader#unread(char[]) |
| */ |
| 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 |
| * java.io.PushbackReader#skip(long) |
| */ |
| 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 |
| } |
| } |
| |
| /** |
| * java.io.PushbackReader#unread(char[], int, int) |
| */ |
| 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 |
| } |
| } |
| |
| 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()], 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 |
| } |
| } |
| |
| /** |
| * java.io.PushbackReader#unread(int) |
| */ |
| 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 |
| } |
| } |
| |
| /** |
| * 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) { |
| } |
| } |
| } |