1/* 2 * Licensed to the Apache Software Foundation (ASF) under one or more 3 * contributor license agreements. See the NOTICE file distributed with 4 * this work for additional information regarding copyright ownership. 5 * The ASF licenses this file to You under the Apache License, Version 2.0 6 * (the "License"); you may not use this file except in compliance with 7 * the License. You may obtain a copy of the License at 8 * 9 * http://www.apache.org/licenses/LICENSE-2.0 10 * 11 * Unless required by applicable law or agreed to in writing, software 12 * distributed under the License is distributed on an "AS IS" BASIS, 13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 * See the License for the specific language governing permissions and 15 * limitations under the License. 16 */ 17 18package tests.api.java.io; 19 20import java.io.CharArrayReader; 21import java.io.IOException; 22 23import dalvik.annotation.AndroidOnly; 24import dalvik.annotation.TestLevel; 25import dalvik.annotation.TestTargetClass; 26import dalvik.annotation.TestTargetNew; 27 28@TestTargetClass(CharArrayReader.class) 29public class CharArrayReaderTest extends junit.framework.TestCase { 30 31 char[] hw = { 'H', 'e', 'l', 'l', 'o', 'W', 'o', 'r', 'l', 'd' }; 32 33 CharArrayReader cr; 34 35 /** 36 * @tests java.io.CharArrayReader#CharArrayReader(char[]) 37 */ 38 @TestTargetNew( 39 level = TestLevel.COMPLETE, 40 notes = "Verifies CharArrayReader(char[] buf) constructor.", 41 method = "CharArrayReader", 42 args = {char[].class} 43 ) 44 public void test_Constructor$C() { 45 // Test for method java.io.CharArrayReader(char []) 46 47 try { 48 cr = new CharArrayReader(hw); 49 assertTrue("Failed to create reader", cr.ready()); 50 } catch (IOException e) { 51 fail("Exception determining ready state : " + e.getMessage()); 52 } 53 } 54 55 /** 56 * @tests java.io.CharArrayReader#CharArrayReader(char[], int, int) 57 */ 58 @TestTargetNew( 59 level = TestLevel.COMPLETE, 60 method = "CharArrayReader", 61 args = {char[].class, int.class, int.class} 62 ) 63 public void test_Constructor$CII() throws IOException { 64 try { 65 cr = new CharArrayReader(null, 0, 0); 66 fail("Test 1: NullPointerException expected."); 67 } catch (NullPointerException e) { 68 // Expected. 69 } 70 try { 71 cr = new CharArrayReader(hw, -1, 0); 72 fail("Test 2: IllegalArgumentException expected."); 73 } catch (IllegalArgumentException e) { 74 // Expected. 75 } 76 try { 77 cr = new CharArrayReader(hw, 0, -1); 78 fail("Test 3: IllegalArgumentException expected."); 79 } catch (IllegalArgumentException e) { 80 // Expected. 81 } 82 try { 83 cr = new CharArrayReader(hw, hw.length + 1, 1); 84 fail("Test 4: IllegalArgumentException expected."); 85 } catch (IllegalArgumentException e) { 86 // Expected. 87 } 88 89 cr = new CharArrayReader(hw, 5, 5); 90 assertTrue("Test 5: Failed to create reader", cr.ready()); 91 assertEquals("Test 6: Incorrect character read;", 92 'W', cr.read()); 93 } 94 95 /** 96 * @tests java.io.CharArrayReader#close() 97 */ 98 @TestTargetNew( 99 level = TestLevel.COMPLETE, 100 notes = "Verifies close() method.", 101 method = "close", 102 args = {} 103 ) 104 public void test_close() { 105 cr = new CharArrayReader(hw); 106 cr.close(); 107 try { 108 cr.read(); 109 fail("Failed to throw exception on read from closed stream"); 110 } catch (IOException e) { 111 // Expected. 112 } 113 114 } 115 116 /** 117 * @tests java.io.CharArrayReader#mark(int) 118 */ 119 @TestTargetNew( 120 level = TestLevel.COMPLETE, 121 method = "mark", 122 args = {int.class} 123 ) 124 public void test_markI() throws IOException { 125 // Test for method void java.io.CharArrayReader.mark(int) 126 cr = new CharArrayReader(hw); 127 cr.skip(5L); 128 cr.mark(100); 129 cr.read(); 130 cr.reset(); 131 assertEquals("Test 1: Failed to mark correct position;", 132 'W', cr.read()); 133 134 cr.close(); 135 try { 136 cr.mark(100); 137 fail("Test 2: IOException expected."); 138 } catch (IOException e) { 139 // Expected. 140 } 141 } 142 143 /** 144 * @tests java.io.CharArrayReader#markSupported() 145 */ 146 @TestTargetNew( 147 level = TestLevel.COMPLETE, 148 notes = "Verifies markSupported() method.", 149 method = "markSupported", 150 args = {} 151 ) 152 public void test_markSupported() { 153 // Test for method boolean java.io.CharArrayReader.markSupported() 154 cr = new CharArrayReader(hw); 155 assertTrue("markSupported returned false", cr.markSupported()); 156 } 157 158 /** 159 * @tests java.io.CharArrayReader#read() 160 */ 161 @TestTargetNew( 162 level = TestLevel.COMPLETE, 163 method = "read", 164 args = {} 165 ) 166 public void test_read() throws IOException { 167 cr = new CharArrayReader(hw); 168 assertEquals("Test 1: Read returned incorrect char;", 169 'H', cr.read()); 170 cr = new CharArrayReader(new char[] { '\u8765' }); 171 assertTrue("Test 2: Incorrect double byte char;", 172 cr.read() == '\u8765'); 173 174 cr.close(); 175 try { 176 cr.read(); 177 fail("Test 3: IOException expected."); 178 } catch (IOException e) { 179 // Expected. 180 } 181 } 182 183 /** 184 * @tests java.io.CharArrayReader#read(char[], int, int) 185 */ 186 @TestTargetNew( 187 level = TestLevel.COMPLETE, 188 method = "read", 189 args = {char[].class, int.class, int.class} 190 ) 191 @AndroidOnly("The RI throws an IndexOutOfBoundsException instead of an" + 192 "ArrayIndexOutOfBoundsException. The RI specification does not" + 193 "define the expected behavior.") 194 public void test_read$CII() throws IOException { 195 // Test for method int java.io.CharArrayReader.read(char [], int, int) 196 char[] c = new char[11]; 197 cr = new CharArrayReader(hw); 198 cr.read(c, 1, 10); 199 assertTrue("Test 1: Read returned incorrect chars.", 200 new String(c, 1, 10).equals(new String(hw, 0, 10))); 201 202 // Illegal argument checks. 203 try { 204 cr.read(null, 1, 0); 205 fail("Test 2: NullPointerException expected."); 206 } catch (NullPointerException e) { 207 // Expected. 208 } 209 210 try { 211 cr.read(c , -1, 1); 212 fail("Test 3: ArrayIndexOutOfBoundsException expected."); 213 } catch (IndexOutOfBoundsException e) { 214 // Expected 215 } 216 217 try { 218 cr.read(c , 1, -1); 219 fail("Test 4: ArrayIndexOutOfBoundsException expected."); 220 } catch (IndexOutOfBoundsException e) { 221 // Expected 222 } 223 224 try { 225 cr.read(c, 1, c.length); 226 fail("Test 5: ArrayIndexOutOfBoundsException expected."); 227 } catch (IndexOutOfBoundsException e) { 228 // Expected 229 } 230 231 cr.close(); 232 try { 233 cr.read(c, 1, 1); 234 fail("Test 6: IOException expected."); 235 } catch (IOException e) { 236 // Expected. 237 } 238 } 239 240 /** 241 * @tests java.io.CharArrayReader#ready() 242 */ 243 @TestTargetNew( 244 level = TestLevel.COMPLETE, 245 notes = "Verifies ready() method.", 246 method = "ready", 247 args = {} 248 ) 249 public void test_ready() { 250 // Test for method boolean java.io.CharArrayReader.ready() 251 cr = new CharArrayReader(hw); 252 boolean expectException = false; 253 try { 254 assertTrue("ready returned false", cr.ready()); 255 cr.skip(1000); 256 assertTrue("ready returned true", !cr.ready()); 257 cr.close(); 258 expectException = true; 259 cr.ready(); 260 fail("No exception 1"); 261 } catch (IOException e) { 262 if (!expectException) 263 fail("Unexpected: " + e); 264 } 265 try { 266 cr = new CharArrayReader(hw); 267 cr.close(); 268 cr.ready(); 269 fail("No exception 2"); 270 } catch (IOException e) { 271 } 272 273 } 274 275 /** 276 * @tests java.io.CharArrayReader#reset() 277 */ 278 @TestTargetNew( 279 level = TestLevel.COMPLETE, 280 method = "reset", 281 args = {} 282 ) 283 public void test_reset() throws IOException { 284 cr = new CharArrayReader(hw); 285 cr.skip(5L); 286 cr.mark(100); 287 cr.read(); 288 cr.reset(); 289 assertEquals("Test 1: Reset failed to return to marker position.", 290 'W', cr.read()); 291 292 cr.close(); 293 try { 294 cr.reset(); 295 fail("Test 2: IOException expected."); 296 } catch (IOException e) { 297 // Expected. 298 } 299 } 300 301 /** 302 * @tests java.io.CharArrayReader#skip(long) 303 */ 304 @TestTargetNew( 305 level = TestLevel.COMPLETE, 306 method = "skip", 307 args = {long.class} 308 ) 309 public void test_skipJ() throws IOException { 310 long skipped = 0; 311 cr = new CharArrayReader(hw); 312 skipped = cr.skip(5L); 313 assertEquals("Test 1: Failed to skip correct number of chars;", 314 5L, skipped); 315 assertEquals("Test 2: Skip skipped wrong chars;", 316 'W', cr.read()); 317 318 cr.close(); 319 try { 320 cr.skip(1); 321 fail("Test 3: IOException expected."); 322 } catch (IOException e) { 323 // Expected. 324 } 325 } 326 327 /** 328 * Sets up the fixture, for example, open a network connection. This method 329 * is called before a test is executed. 330 */ 331 protected void setUp() { 332 } 333 334 /** 335 * Tears down the fixture, for example, close a network connection. This 336 * method is called after a test is executed. 337 */ 338 protected void tearDown() { 339 if (cr != null) 340 cr.close(); 341 } 342} 343