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.BufferedWriter; 21import java.io.IOException; 22 23import tests.support.Support_ASimpleWriter; 24import tests.support.Support_StringWriter; 25import dalvik.annotation.TestLevel; 26import dalvik.annotation.TestTargetClass; 27import dalvik.annotation.TestTargetNew; 28 29@TestTargetClass(BufferedWriter.class) 30public class BufferedWriterTest extends junit.framework.TestCase { 31 32 BufferedWriter bw; 33 34 Support_StringWriter sw; 35 36 Support_ASimpleWriter ssw; 37 38 public String testString = "Test_All_Tests\nTest_java_io_BufferedInputStream\nTest_java_io_BufferedOutputStream\nTest_java_io_ByteArrayInputStream\nTest_java_io_ByteArrayOutputStream\nTest_java_io_DataInputStream\nTest_java_io_File\nTest_java_io_FileDescriptor\nTest_java_io_FileInputStream\nTest_java_io_FileNotFoundException\nTest_java_io_FileOutputStream\nTest_java_io_FilterInputStream\nTest_java_io_FilterOutputStream\nTest_java_io_InputStream\nTest_java_io_IOException\nTest_java_io_OutputStream\nTest_java_io_PrintStream\nTest_java_io_RandomAccessFile\nTest_java_io_SyncFailedException\nTest_java_lang_AbstractMethodError\nTest_java_lang_ArithmeticException\nTest_java_lang_ArrayIndexOutOfBoundsException\nTest_java_lang_ArrayStoreException\nTest_java_lang_Boolean\nTest_java_lang_Byte\nTest_java_lang_Character\nTest_java_lang_Class\nTest_java_lang_ClassCastException\nTest_java_lang_ClassCircularityError\nTest_java_lang_ClassFormatError\nTest_java_lang_ClassLoader\nTest_java_lang_ClassNotFoundException\nTest_java_lang_CloneNotSupportedException\nTest_java_lang_Double\nTest_java_lang_Error\nTest_java_lang_Exception\nTest_java_lang_ExceptionInInitializerError\nTest_java_lang_Float\nTest_java_lang_IllegalAccessError\nTest_java_lang_IllegalAccessException\nTest_java_lang_IllegalArgumentException\nTest_java_lang_IllegalMonitorStateException\nTest_java_lang_IllegalThreadStateException\nTest_java_lang_IncompatibleClassChangeError\nTest_java_lang_IndexOutOfBoundsException\nTest_java_lang_InstantiationError\nTest_java_lang_InstantiationException\nTest_java_lang_Integer\nTest_java_lang_InternalError\nTest_java_lang_InterruptedException\nTest_java_lang_LinkageError\nTest_java_lang_Long\nTest_java_lang_Math\nTest_java_lang_NegativeArraySizeException\nTest_java_lang_NoClassDefFoundError\nTest_java_lang_NoSuchFieldError\nTest_java_lang_NoSuchMethodError\nTest_java_lang_NullPointerException\nTest_java_lang_Number\nTest_java_lang_NumberFormatException\nTest_java_lang_Object\nTest_java_lang_OutOfMemoryError\nTest_java_lang_RuntimeException\nTest_java_lang_SecurityManager\nTest_java_lang_Short\nTest_java_lang_StackOverflowError\nTest_java_lang_String\nTest_java_lang_StringBuffer\nTest_java_lang_StringIndexOutOfBoundsException\nTest_java_lang_System\nTest_java_lang_Thread\nTest_java_lang_ThreadDeath\nTest_java_lang_ThreadGroup\nTest_java_lang_Throwable\nTest_java_lang_UnknownError\nTest_java_lang_UnsatisfiedLinkError\nTest_java_lang_VerifyError\nTest_java_lang_VirtualMachineError\nTest_java_lang_vm_Image\nTest_java_lang_vm_MemorySegment\nTest_java_lang_vm_ROMStoreException\nTest_java_lang_vm_VM\nTest_java_lang_Void\nTest_java_net_BindException\nTest_java_net_ConnectException\nTest_java_net_DatagramPacket\nTest_java_net_DatagramSocket\nTest_java_net_DatagramSocketImpl\nTest_java_net_InetAddress\nTest_java_net_NoRouteToHostException\nTest_java_net_PlainDatagramSocketImpl\nTest_java_net_PlainSocketImpl\nTest_java_net_Socket\nTest_java_net_SocketException\nTest_java_net_SocketImpl\nTest_java_net_SocketInputStream\nTest_java_net_SocketOutputStream\nTest_java_net_UnknownHostException\nTest_java_util_ArrayEnumerator\nTest_java_util_Date\nTest_java_util_EventObject\nTest_java_util_HashEnumerator\nTest_java_util_Hashtable\nTest_java_util_Properties\nTest_java_util_ResourceBundle\nTest_java_util_tm\nTest_java_util_Vector\n"; 39 40 /** 41 * @tests java.io.BufferedWriter#BufferedWriter(java.io.Writer) 42 */ 43 @TestTargetNew( 44 level = TestLevel.COMPLETE, 45 method = "BufferedWriter", 46 args = {java.io.Writer.class} 47 ) 48 public void test_ConstructorLjava_io_Writer() { 49 bw = new BufferedWriter(sw); 50 try { 51 bw.write("Hi", 0, 2); 52 assertTrue("Test 1: Buffering failed.", sw.toString().equals("")); 53 bw.flush(); 54 assertEquals("Test 2: Incorrect value;", "Hi", sw.toString()); 55 } catch (IOException e) { 56 fail("Test 3: Unexpected IOException."); 57 } 58 } 59 60 /** 61 * @tests java.io.BufferedWriter#BufferedWriter(java.io.Writer, int) 62 */ 63 @TestTargetNew( 64 level = TestLevel.COMPLETE, 65 method = "BufferedWriter", 66 args = {java.io.Writer.class, int.class} 67 ) 68 public void test_ConstructorLjava_io_WriterI() { 69 try { 70 bw = new BufferedWriter(sw, 0); 71 fail("Test 1: IllegalArgumentException expected."); 72 } catch (IllegalArgumentException expected) { 73 // Expected. 74 } 75 76 bw = new BufferedWriter(sw, 10); 77 try { 78 bw.write("Hi", 0, 2); 79 assertTrue("Test 2: Buffering failed.", sw.toString().equals("")); 80 bw.flush(); 81 assertEquals("Test 3: Incorrect value;", "Hi", sw.toString()); 82 } catch (IOException e) { 83 fail("Test 4: Unexpected IOException."); 84 } 85 } 86 87 /** 88 * @tests java.io.BufferedWriter#close() 89 */ 90 @TestTargetNew( 91 level = TestLevel.COMPLETE, 92 method = "close", 93 args = {} 94 ) 95 public void test_close() { 96 // Test for method void java.io.BufferedWriter.close() 97 try { 98 bw.close(); 99 bw.write(testString); 100 fail("Test 1: IOException expected."); 101 } catch (IOException e) { 102 // Expected. 103 } 104 assertFalse("Test 2: Write after close.", sw.toString().equals(testString)); 105 106 bw = new BufferedWriter(ssw); 107 try { 108 bw.close(); 109 fail("Test 3: IOException expected."); 110 } catch (IOException e) { 111 // Expected. 112 } 113 } 114 115 /** 116 * @tests java.io.BufferedWriter#flush() 117 */ 118 @TestTargetNew( 119 level = TestLevel.COMPLETE, 120 method = "flush", 121 args = {} 122 ) 123 public void test_flush() throws IOException { 124 bw.write("This should not cause a flush"); 125 assertTrue("Test 1: Bytes written without flush.", 126 sw.toString().equals("")); 127 bw.flush(); 128 assertEquals("Test 2: Bytes not flushed.", 129 "This should not cause a flush", sw.toString()); 130 131 bw.close(); 132 bw = new BufferedWriter(ssw); 133 try { 134 bw.flush(); 135 fail("Test 3: IOException expected."); 136 } catch (IOException e) { 137 // Expected. 138 } 139 } 140 141 /** 142 * @tests java.io.BufferedWriter#newLine() 143 */ 144 @TestTargetNew( 145 level = TestLevel.COMPLETE, 146 method = "newLine", 147 args = {} 148 ) 149 public void test_newLine() throws IOException { 150 String separator = System.getProperty("line.separator"); 151 bw.write("Hello"); 152 bw.newLine(); 153 bw.write("World"); 154 bw.flush(); 155 assertTrue("Test 1: Incorrect string written: " + sw.toString(), 156 sw.toString().equals("Hello" + separator + "World")); 157 158 bw.close(); 159 bw = new BufferedWriter(ssw, 1); 160 try { 161 bw.newLine(); 162 fail("Test 2: IOException expected."); 163 } catch (IOException e) { 164 // Expected. 165 } 166 } 167 168 /** 169 * @tests java.io.BufferedWriter#write(char[], int, int) 170 */ 171 @TestTargetNew( 172 level = TestLevel.PARTIAL_COMPLETE, 173 method = "write", 174 args = {char[].class, int.class, int.class} 175 ) 176 public void test_write$CII() { 177 // Test for method void java.io.BufferedWriter.write(char [], int, int) 178 try { 179 char[] testCharArray = testString.toCharArray(); 180 bw.write(testCharArray, 500, 1000); 181 bw.flush(); 182 assertTrue("Incorrect string written", sw.toString().equals( 183 testString.substring(500, 1500))); 184 185 int idx = sw.toString().length(); 186 bw.write(testCharArray, 0, testCharArray.length); 187 assertEquals(idx + testCharArray.length, sw.toString().length()); 188 bw.write(testCharArray, 0, 0); 189 assertEquals(idx + testCharArray.length, sw.toString().length()); 190 bw.write(testCharArray, testCharArray.length, 0); 191 assertEquals(idx + testCharArray.length, sw.toString().length()); 192 } catch (Exception e) { 193 fail("Exception during write test"); 194 } 195 196 } 197 198 /** 199 * @tests java.io.BufferedWriter#write(char[], int, int) 200 */ 201 @TestTargetNew( 202 level = TestLevel.PARTIAL_COMPLETE, 203 notes = "Illegal argument tests.", 204 method = "write", 205 args = {char[].class, int.class, int.class} 206 ) 207 public void test_write$CII_Exception() throws IOException { 208 char[] nullCharArray = null; 209 char[] charArray = testString.toCharArray(); 210 211 try { 212 bw.write(nullCharArray, 0, 1); 213 fail("Test 1: NullPointerException expected."); 214 } catch (NullPointerException e) { 215 // Expected. 216 } 217 218 try { 219 bw.write(charArray, -1, 0); 220 fail("Test 2: IndexOutOfBoundsException expected."); 221 } catch (IndexOutOfBoundsException e) { 222 // Expected 223 } 224 225 try { 226 bw.write(charArray, 0, -1); 227 fail("Test 3: IndexOutOfBoundsException expected."); 228 } catch (IndexOutOfBoundsException e) { 229 // Expected 230 } 231 232 try { 233 bw.write(charArray, charArray.length + 1, 0); 234 fail("Test 4: IndexOutOfBoundsException expected."); 235 } catch (IndexOutOfBoundsException e) { 236 // Expected 237 } 238 239 try { 240 bw.write(charArray, charArray.length, 1); 241 fail("Test 5: IndexOutOfBoundsException expected."); 242 } catch (IndexOutOfBoundsException e) { 243 // Expected 244 } 245 246 try { 247 bw.write(charArray, 0, charArray.length + 1); 248 fail("Test 6: IndexOutOfBoundsException expected."); 249 } catch (IndexOutOfBoundsException e) { 250 // Expected 251 } 252 253 try { 254 bw.write(charArray, 1, charArray.length); 255 fail("Test 7: IndexOutOfBoundsException expected."); 256 } catch (IndexOutOfBoundsException e) { 257 // Expected 258 } 259 260 bw.close(); 261 262 try { 263 bw.write(charArray, 0, 1); 264 fail("Test 7: IOException expected."); 265 } catch (IOException e) { 266 // Expected. 267 } 268 269 bw = new BufferedWriter(ssw, charArray.length / 2); 270 try { 271 bw.write(charArray, 0, charArray.length); 272 fail("Test 8: IOException expected."); 273 } catch (IOException e) { 274 // Expected. 275 } 276 } 277 278 /** 279 * @tests java.io.BufferedWriter#write(int) 280 */ 281 @TestTargetNew( 282 level = TestLevel.COMPLETE, 283 method = "write", 284 args = {int.class} 285 ) 286 public void test_writeI() throws IOException { 287 bw.write('T'); 288 assertTrue("Test 1: Char written without flush.", 289 sw.toString().equals("")); 290 bw.flush(); 291 assertEquals("Test 2: Incorrect char written;", 292 "T", sw.toString()); 293 294 bw.close(); 295 try { 296 bw.write('E'); 297 fail("Test 3: IOException expected since the target writer is closed."); 298 } catch (IOException e) { 299 // Expected. 300 } 301 302 // IOException should be thrown when the buffer is full and data is 303 // written out to the target writer. 304 bw = new BufferedWriter(ssw, 1); 305 bw.write('S'); 306 try { 307 bw.write('T'); 308 fail("Test 4: IOException expected since the target writer throws it."); 309 } catch (IOException e) { 310 // Expected. 311 } 312 } 313 314 /** 315 * @tests java.io.BufferedWriter#write(java.lang.String, int, int) 316 */ 317 @TestTargetNew( 318 level = TestLevel.PARTIAL_COMPLETE, 319 method = "write", 320 args = {java.lang.String.class, int.class, int.class} 321 ) 322 public void test_writeLjava_lang_StringII() { 323 // Test for method void java.io.BufferedWriter.write(java.lang.String, 324 // int, int) 325 try { 326 bw.write(testString); 327 bw.flush(); 328 assertTrue("Incorrect string written", sw.toString().equals( 329 testString)); 330 } catch (Exception e) { 331 fail("Exception during write test"); 332 } 333 } 334 335 /** 336 * @tests java.io.BufferedWriter#write(java.lang.String, int, int) 337 */ 338 @TestTargetNew( 339 level = TestLevel.PARTIAL_COMPLETE, 340 notes = "Illegal argument checking.", 341 method = "write", 342 args = {java.lang.String.class, int.class, int.class} 343 ) 344 public void test_writeLjava_lang_StringII_Exception() throws IOException { 345 346 bw.write((String) null , -1, -1); 347 bw.write((String) null , -1, 0); 348 bw.write((String) null , 0 , -1); 349 bw.write((String) null , 0 , 0); 350 351 try { 352 bw.write((String) null, 0, 1); 353 fail("Test 1: NullPointerException expected."); 354 } catch (NullPointerException e) { 355 // Expected. 356 } 357 358 try { 359 bw.write(testString, -1, 1); 360 fail("Test 2: StringIndexOutOfBoundsException expected."); 361 } catch (StringIndexOutOfBoundsException e) { 362 // Expected. 363 } 364 365 try { 366 bw.write(testString, 1, testString.length()); 367 fail("Test 3: StringIndexOutOfBoundsException expected."); 368 } catch (StringIndexOutOfBoundsException e) { 369 // Expected. 370 } 371 372 bw.close(); 373 374 try { 375 bw.write(testString, 0, 1); 376 fail("Test 4: IOException expected."); 377 } catch (IOException e) { 378 // Expected. 379 } 380 381 bw = new BufferedWriter(ssw, testString.length() / 2); 382 try { 383 bw.write(testString, 0, testString.length()); 384 fail("Test 5: IOException expected."); 385 } catch (IOException e) { 386 // Expected. 387 } 388 } 389 390 /** 391 * Sets up the fixture, for example, open a network connection. This method 392 * is called before a test is executed. 393 */ 394 protected void setUp() { 395 sw = new Support_StringWriter(); 396 ssw = new Support_ASimpleWriter(true); 397 bw = new BufferedWriter(sw, 500); 398 } 399 400 /** 401 * Tears down the fixture, for example, close a network connection. This 402 * method is called after a test is executed. 403 */ 404 protected void tearDown() { 405 406 ssw.throwExceptionOnNextUse = false; 407 try { 408 bw.close(); 409 } catch (Exception e) { 410 } 411 } 412} 413