RandomAccessFileTest.java revision 561ee011997c6c2f1befbfaa9d5f0a99771c1d63
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 org.apache.harmony.luni.tests.java.io; 19 20import java.io.EOFException; 21import java.io.File; 22import java.io.FileInputStream; 23import java.io.FileNotFoundException; 24import java.io.FileOutputStream; 25import java.io.IOException; 26import java.io.RandomAccessFile; 27import java.nio.channels.FileChannel; 28import java.nio.channels.NonWritableChannelException; 29 30public class RandomAccessFileTest extends junit.framework.TestCase { 31 32 public String fileName; 33 34 public boolean ufile = true; 35 36 java.io.RandomAccessFile raf; 37 38 java.io.File f; 39 40 String unihw = "\u0048\u0065\u006C\u0801\u006C\u006F\u0020\u0057\u0081\u006F\u0072\u006C\u0064"; 41 42 //java.io.FileOutputStream fos; 43 44 public String fileString = "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_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"; 45 46 /** 47 * @tests java.io.RandomAccessFile#RandomAccessFile(java.io.File, 48 * java.lang.String) 49 */ 50 public void test_ConstructorLjava_io_FileLjava_lang_String() 51 throws Exception { 52 // Test for method java.io.RandomAccessFile(java.io.File, 53 // java.lang.String) 54 RandomAccessFile raf = new java.io.RandomAccessFile(f, "rw"); 55 raf.write(20); 56 raf.seek(0); 57 assertEquals("Incorrect int read/written", 20, raf.read()); 58 raf.close(); 59 60 raf = new java.io.RandomAccessFile(f, "rwd"); 61 raf.write(20); 62 raf.seek(0); 63 assertEquals("Incorrect int read/written", 20, raf.read()); 64 raf.close(); 65 66 raf = new java.io.RandomAccessFile(f, "rws"); 67 raf.write(20); 68 raf.seek(0); 69 assertEquals("Incorrect int read/written", 20, raf.read()); 70 raf.close(); 71 72 // Regression for HARMONY-50 73 File f = File.createTempFile("xxx", "yyy"); 74 f.deleteOnExit(); 75 raf = new RandomAccessFile(f, "rws"); 76 raf.close(); 77 78 f = File.createTempFile("xxx", "yyy"); 79 f.deleteOnExit(); 80 raf = new RandomAccessFile(f, "rwd"); 81 raf.close(); 82 } 83 84 /** 85 * @tests java.io.RandomAccessFile#RandomAccessFile(java.lang.String, 86 * java.lang.String) 87 */ 88 public void test_ConstructorLjava_lang_StringLjava_lang_String() 89 throws IOException { 90 // Test for method java.io.RandomAccessFile(java.lang.String, 91 // java.lang.String) 92 RandomAccessFile raf = new java.io.RandomAccessFile(fileName, "rw"); 93 raf.write("Test".getBytes(), 0, 4); 94 raf.close(); 95 96 raf = new java.io.RandomAccessFile(fileName, "rwd"); 97 raf.write("Test".getBytes(), 0, 4); 98 raf.close(); 99 100 raf = new java.io.RandomAccessFile(fileName, "rws"); 101 raf.write("Test".getBytes(), 0, 4); 102 raf.close(); 103 } 104 105 /** 106 * @tests java.io.RandomAccessFile#RandomAccessFile(java.lang.String, 107 * java.lang.String) 108 */ 109 public void test_ConstructorLjava_lang_StringLjava_lang_String_I() 110 throws IOException { 111 RandomAccessFile raf = null; 112 try { 113 raf = new RandomAccessFile("", "r"); 114 fail("should throw FileNotFoundException."); 115 } catch (FileNotFoundException e) { 116 // Expected 117 } finally { 118 if (raf != null) { 119 raf.close(); 120 raf = null; 121 } 122 } 123 try { 124 raf = new RandomAccessFile(new File(""), "r"); 125 fail("should throw FileNotFoundException."); 126 } catch (FileNotFoundException e) { 127 // Expected 128 } finally { 129 if (raf != null) { 130 raf.close(); 131 raf = null; 132 } 133 } 134 File tmpDir = new File("tmpDir"); 135 assertTrue(tmpDir.mkdir()); 136 tmpDir.deleteOnExit(); 137 try { 138 raf = new RandomAccessFile(tmpDir.getPath(), "r"); 139 fail("should throw FileNotFoundException."); 140 } catch (FileNotFoundException e) { 141 // Expected 142 } finally { 143 if (raf != null) { 144 raf.close(); 145 raf = null; 146 } 147 } 148 } 149 150 /** 151 * @tests java.io.RandomAccessFile#close() 152 */ 153 public void test_close() { 154 // Test for method void java.io.RandomAccessFile.close() 155 try { 156 RandomAccessFile raf = new java.io.RandomAccessFile(fileName, "rw"); 157 raf.close(); 158 raf.write("Test".getBytes(), 0, 4); 159 fail("Failed to close file properly"); 160 } catch (IOException e) {} 161 } 162 163 /** 164 * @tests java.io.RandomAccessFile#getFD() 165 */ 166 public void test_getFD() throws IOException { 167 // Test for method java.io.FileDescriptor 168 // java.io.RandomAccessFile.getFD() 169 170 RandomAccessFile raf = new java.io.RandomAccessFile(fileName, "rw"); 171 assertTrue("Returned invalid fd", raf.getFD().valid()); 172 173 raf.close(); 174 assertFalse("Returned valid fd after close", raf.getFD().valid()); 175 } 176 177 /** 178 * @tests java.io.RandomAccessFile#getFilePointer() 179 */ 180 public void test_getFilePointer() throws IOException { 181 // Test for method long java.io.RandomAccessFile.getFilePointer() 182 RandomAccessFile raf = new java.io.RandomAccessFile(fileName, "rw"); 183 raf.write(fileString.getBytes(), 0, 1000); 184 assertEquals("Incorrect filePointer returned", 1000, raf 185 .getFilePointer()); 186 raf.close(); 187 } 188 189 /** 190 * @tests java.io.RandomAccessFile#length() 191 */ 192 public void test_length() throws IOException { 193 // Test for method long java.io.RandomAccessFile.length() 194 RandomAccessFile raf = new java.io.RandomAccessFile(fileName, "rw"); 195 raf.write(fileString.getBytes()); 196 assertEquals("Incorrect length returned", fileString.length(), raf 197 .length()); 198 raf.close(); 199 } 200 201 /** 202 * @tests java.io.RandomAccessFile#read() 203 */ 204 public void test_read() throws IOException { 205 // Test for method int java.io.RandomAccessFile.read() 206 FileOutputStream fos = new java.io.FileOutputStream(fileName); 207 fos.write(fileString.getBytes("UTF-8"), 0, fileString.length()); 208 fos.close(); 209 210 RandomAccessFile raf = new java.io.RandomAccessFile(fileName, "r"); 211 assertEquals("Incorrect bytes returned from read", 212 fileString.charAt(0), raf.read()); 213 raf.close(); 214 } 215 216 /** 217 * @tests java.io.RandomAccessFile#read(byte[]) 218 */ 219 public void test_read$B() throws IOException { 220 // Test for method int java.io.RandomAccessFile.read(byte []) 221 FileOutputStream fos = new java.io.FileOutputStream(fileName); 222 fos.write(fileString.getBytes(), 0, fileString.length()); 223 fos.close(); 224 225 RandomAccessFile raf = new java.io.RandomAccessFile(fileName, "r"); 226 byte[] rbuf = new byte[4000]; 227 raf.read(rbuf); 228 assertEquals("Incorrect bytes returned from read", fileString, 229 new String(rbuf, 0, fileString.length())); 230 raf.close(); 231 } 232 233 /** 234 * @tests java.io.RandomAccessFile#read(byte[], int, int) 235 */ 236 public void test_read$BII() throws IOException { 237 // Test for method int java.io.RandomAccessFile.read(byte [], int, int) 238 RandomAccessFile raf = new java.io.RandomAccessFile(fileName, "rw"); 239 byte[] rbuf = new byte[4000]; 240 FileOutputStream fos = new java.io.FileOutputStream(fileName); 241 fos.write(fileString.getBytes(), 0, fileString.length()); 242 fos.close(); 243 raf.read(rbuf, 0, fileString.length()); 244 assertEquals("Incorrect bytes returned from read", fileString, 245 new String(rbuf, 0, fileString.length())); 246 raf.close(); 247 } 248 249 /** 250 * @tests java.io.RandomAccessFile#readBoolean() 251 */ 252 public void test_readBoolean() throws IOException { 253 // Test for method boolean java.io.RandomAccessFile.readBoolean() 254 RandomAccessFile raf = new java.io.RandomAccessFile(fileName, "rw"); 255 raf.writeBoolean(true); 256 raf.seek(0); 257 assertTrue("Incorrect boolean read/written", raf.readBoolean()); 258 raf.close(); 259 } 260 261 /** 262 * @tests java.io.RandomAccessFile#readByte() 263 */ 264 public void test_readByte() throws IOException { 265 // Test for method byte java.io.RandomAccessFile.readByte() 266 RandomAccessFile raf = new java.io.RandomAccessFile(fileName, "rw"); 267 raf.writeByte(127); 268 raf.seek(0); 269 assertEquals("Incorrect bytes read/written", 127, raf.readByte()); 270 raf.close(); 271 } 272 273 /** 274 * @tests java.io.RandomAccessFile#readChar() 275 */ 276 public void test_readChar() throws IOException { 277 // Test for method char java.io.RandomAccessFile.readChar() 278 RandomAccessFile raf = new java.io.RandomAccessFile(fileName, "rw"); 279 raf.writeChar('T'); 280 raf.seek(0); 281 assertEquals("Incorrect char read/written", 'T', raf.readChar()); 282 raf.close(); 283 } 284 285 /** 286 * @tests java.io.RandomAccessFile#readDouble() 287 */ 288 public void test_readDouble() throws IOException { 289 // Test for method double java.io.RandomAccessFile.readDouble() 290 RandomAccessFile raf = new java.io.RandomAccessFile(fileName, "rw"); 291 raf.writeDouble(Double.MAX_VALUE); 292 raf.seek(0); 293 assertEquals("Incorrect double read/written", Double.MAX_VALUE, raf 294 .readDouble(), 0); 295 raf.close(); 296 } 297 298 /** 299 * @tests java.io.RandomAccessFile#readFloat() 300 */ 301 public void test_readFloat() throws IOException { 302 // Test for method float java.io.RandomAccessFile.readFloat() 303 RandomAccessFile raf = new java.io.RandomAccessFile(fileName, "rw"); 304 raf.writeFloat(Float.MAX_VALUE); 305 raf.seek(0); 306 assertEquals("Incorrect float read/written", Float.MAX_VALUE, raf 307 .readFloat(), 0); 308 raf.close(); 309 } 310 311 /** 312 * @tests java.io.RandomAccessFile#readFully(byte[]) 313 */ 314 public void test_readFully$B() throws IOException { 315 // Test for method void java.io.RandomAccessFile.readFully(byte []) 316 byte[] buf = new byte[10]; 317 RandomAccessFile raf = new java.io.RandomAccessFile(fileName, "rw"); 318 raf.writeBytes("HelloWorld"); 319 raf.seek(0); 320 raf.readFully(buf); 321 assertEquals("Incorrect bytes read/written", "HelloWorld", new String( 322 buf, 0, 10, "UTF-8")); 323 raf.close(); 324 } 325 326 /** 327 * @tests java.io.RandomAccessFile#readFully(byte[], int, int) 328 */ 329 public void test_readFully$BII() throws IOException { 330 // Test for method void java.io.RandomAccessFile.readFully(byte [], int, 331 // int) 332 byte[] buf = new byte[10]; 333 RandomAccessFile raf = new java.io.RandomAccessFile(fileName, "rw"); 334 raf.writeBytes("HelloWorld"); 335 raf.seek(0); 336 raf.readFully(buf, 0, buf.length); 337 assertEquals("Incorrect bytes read/written", "HelloWorld", new String( 338 buf, 0, 10, "UTF-8")); 339 try { 340 raf.readFully(buf, 0, buf.length); 341 fail("Reading past end of buffer did not throw EOFException"); 342 } catch (EOFException e) {} 343 raf.close(); 344 } 345 346 /** 347 * @tests java.io.RandomAccessFile#readInt() 348 */ 349 public void test_readInt() throws IOException { 350 // Test for method int java.io.RandomAccessFile.readInt() 351 RandomAccessFile raf = new java.io.RandomAccessFile(fileName, "rw"); 352 raf.writeInt(Integer.MIN_VALUE); 353 raf.seek(0); 354 assertEquals("Incorrect int read/written", Integer.MIN_VALUE, raf 355 .readInt()); 356 raf.close(); 357 } 358 359 /** 360 * @tests java.io.RandomAccessFile#readLine() 361 */ 362 public void test_readLine() throws IOException { 363 // Test for method java.lang.String java.io.RandomAccessFile.readLine() 364 RandomAccessFile raf = new java.io.RandomAccessFile(fileName, "rw"); 365 String s = "Goodbye\nCruel\nWorld\n"; 366 raf.write(s.getBytes("UTF-8"), 0, s.length()); 367 raf.seek(0); 368 369 assertEquals("Goodbye", raf.readLine()); 370 assertEquals("Cruel", raf.readLine()); 371 assertEquals("World", raf.readLine()); 372 373 raf.close(); 374 } 375 376 /** 377 * @tests java.io.RandomAccessFile#readLong() 378 */ 379 public void test_readLong() throws IOException { 380 // Test for method long java.io.RandomAccessFile.readLong() 381 RandomAccessFile raf = new java.io.RandomAccessFile(fileName, "rw"); 382 raf.writeLong(Long.MAX_VALUE); 383 raf.seek(0); 384 assertEquals("Incorrect long read/written", Long.MAX_VALUE, raf 385 .readLong()); 386 raf.close(); 387 } 388 389 /** 390 * @tests java.io.RandomAccessFile#readShort() 391 */ 392 public void test_readShort() throws IOException { 393 // Test for method short java.io.RandomAccessFile.readShort() 394 RandomAccessFile raf = new java.io.RandomAccessFile(fileName, "rw"); 395 raf.writeShort(Short.MIN_VALUE); 396 raf.seek(0); 397 assertEquals("Incorrect long read/written", Short.MIN_VALUE, raf 398 .readShort()); 399 raf.close(); 400 } 401 402 /** 403 * @tests java.io.RandomAccessFile#readUnsignedByte() 404 */ 405 public void test_readUnsignedByte() throws IOException { 406 // Test for method int java.io.RandomAccessFile.readUnsignedByte() 407 RandomAccessFile raf = new java.io.RandomAccessFile(fileName, "rw"); 408 raf.writeByte(-1); 409 raf.seek(0); 410 assertEquals("Incorrect byte read/written", 255, raf.readUnsignedByte()); 411 raf.close(); 412 } 413 414 /** 415 * @tests java.io.RandomAccessFile#readUnsignedShort() 416 */ 417 public void test_readUnsignedShort() throws IOException { 418 // Test for method int java.io.RandomAccessFile.readUnsignedShort() 419 RandomAccessFile raf = new java.io.RandomAccessFile(fileName, "rw"); 420 raf.writeShort(-1); 421 raf.seek(0); 422 assertEquals("Incorrect byte read/written", 65535, raf 423 .readUnsignedShort()); 424 raf.close(); 425 } 426 427 /** 428 * @tests java.io.RandomAccessFile#readUTF() 429 */ 430 public void test_readUTF() throws IOException { 431 // Test for method java.lang.String java.io.RandomAccessFile.readUTF() 432 433 RandomAccessFile raf = new java.io.RandomAccessFile(fileName, "rw"); 434 raf.writeUTF(unihw); 435 raf.seek(0); 436 assertEquals("Incorrect utf string read", unihw, raf.readUTF()); 437 raf.close(); 438 } 439 440 /** 441 * @tests java.io.RandomAccessFile#seek(long) 442 */ 443 public void test_seekJ() throws IOException { 444 // Test for method void java.io.RandomAccessFile.seek(long) 445 RandomAccessFile raf = new java.io.RandomAccessFile(fileName, "rw"); 446 raf.write(fileString.getBytes(), 0, fileString.length()); 447 raf.seek(12); 448 assertEquals("Seek failed to set filePointer", 12, raf.getFilePointer()); 449 raf.close(); 450 } 451 452 /** 453 * @tests java.io.RandomAccessFile#skipBytes(int) 454 */ 455 public void test_skipBytesI() throws IOException { 456 // Test for method int java.io.RandomAccessFile.skipBytes(int) 457 byte[] buf = new byte[5]; 458 RandomAccessFile raf = new java.io.RandomAccessFile(fileName, "rw"); 459 raf.writeBytes("HelloWorld"); 460 raf.seek(0); 461 raf.skipBytes(5); 462 raf.readFully(buf); 463 assertEquals("Failed to skip bytes", "World", new String(buf, 0, 5, "UTF-8")); 464 raf.close(); 465 } 466 467 /** 468 * @tests java.io.RandomAccessFile#write(byte[]) 469 */ 470 public void test_write$B() throws IOException { 471 // Test for method void java.io.RandomAccessFile.write(byte []) 472 RandomAccessFile raf = new java.io.RandomAccessFile(fileName, "rw"); 473 474 byte[] nullByteArray = null; 475 try { 476 raf.write(nullByteArray); 477 fail("should throw NullPointerException"); 478 } catch (NullPointerException e) { 479 //expected 480 } 481 482 byte[] rbuf = new byte[4000]; 483 raf.write(fileString.getBytes()); 484 raf.close(); 485 486 try { 487 raf.write(nullByteArray); 488 fail("should throw NullPointerException"); 489 } catch (NullPointerException e) { 490 //expected 491 } 492 493 //will not throw IOException if array's length is 0 494 raf.write(new byte[0]); 495 496 try { 497 raf.write(fileString.getBytes()); 498 fail("should throw IOException"); 499 } catch (IOException e) { 500 //expected 501 } 502 503 FileInputStream fis = new java.io.FileInputStream(fileName); 504 fis.read(rbuf, 0, fileString.length()); 505 assertEquals("Incorrect bytes written", fileString, new String(rbuf, 0, 506 fileString.length())); 507 fis.close(); 508 } 509 510 /** 511 * @tests java.io.RandomAccessFile#write(byte[], int, int) 512 */ 513 public void test_write$BII() throws IOException { 514 // Test for method void java.io.RandomAccessFile.write(byte [], int, 515 // int) 516 RandomAccessFile raf = new java.io.RandomAccessFile(fileName, "rw"); 517 byte[] rbuf = new byte[4000]; 518 raf.write(fileString.getBytes(), 0, fileString.length()); 519 raf.close(); 520 FileInputStream fis = new java.io.FileInputStream(fileName); 521 fis.read(rbuf, 0, fileString.length()); 522 assertEquals("Incorrect bytes written", fileString, new String(rbuf, 0, 523 fileString.length())); 524 fis.close(); 525 } 526 527 /** 528 * @tests java.io.RandomAccessFile#write(byte[], int, int) 529 */ 530 public void test_write_$BII_Exception() throws IOException { 531 raf = new java.io.RandomAccessFile(f, "rw"); 532 byte[] nullByteArray = null; 533 byte[] byteArray = new byte[10]; 534 535 try { 536 raf.write(nullByteArray, -1, -1); 537 fail("should throw NullPointerException"); 538 } catch (NullPointerException e) { 539 // expected 540 } 541 542 try { 543 raf.write(nullByteArray, 0, 0); 544 fail("should throw NullPointerException"); 545 } catch (NullPointerException e) { 546 // expected 547 } 548 549 try { 550 raf.write(nullByteArray, 1, -1); 551 fail("should throw NullPointerException"); 552 } catch (NullPointerException e) { 553 // expected 554 } 555 556 try { 557 raf.write(nullByteArray, 1, 0); 558 fail("should throw NullPointerException"); 559 } catch (NullPointerException e) { 560 // expected 561 } 562 563 try { 564 raf.write(nullByteArray, 1, 1); 565 fail("should throw NullPointerException"); 566 } catch (NullPointerException e) { 567 // expected 568 } 569 570 try { 571 raf.write(byteArray, -1, -1); 572 fail("should throw IndexOutOfBoundsException"); 573 } catch (IndexOutOfBoundsException e) { 574 // expected 575 } 576 577 try { 578 raf.write(byteArray, -1, 0); 579 fail("should throw IndexOutOfBoundsException"); 580 } catch (IndexOutOfBoundsException e) { 581 // expected 582 } 583 584 try { 585 raf.write(byteArray, -1, 1); 586 fail("should throw IndexOutOfBoundsException"); 587 } catch (IndexOutOfBoundsException e) { 588 // expected 589 } 590 591 try { 592 raf.write(byteArray, 0, -1); 593 fail("should throw IndexOutOfBoundsException"); 594 } catch (IndexOutOfBoundsException e) { 595 // expected 596 } 597 598 raf.write(byteArray, 0, 0); 599 raf.write(byteArray, 0, byteArray.length); 600 raf.write(byteArray, 1, 0); 601 raf.write(byteArray, byteArray.length, 0); 602 603 try { 604 raf.write(byteArray, byteArray.length + 1, 0); 605 fail("should throw IndexOutOfBoundsException"); 606 } catch (IndexOutOfBoundsException e) { 607 //expected 608 } 609 610 try { 611 raf.write(byteArray, byteArray.length + 1, 1); 612 fail("should throw IndexOutOfBoundsException"); 613 } catch (IndexOutOfBoundsException e) { 614 //expected 615 } 616 617 raf.close(); 618 619 try { 620 raf.write(nullByteArray, -1, -1); 621 fail("should throw NullPointerException"); 622 } catch (NullPointerException e) { 623 // expected 624 } 625 626 try { 627 raf.write(byteArray, -1, -1); 628 fail("should throw IndexOutOfBoundsException"); 629 } catch (IndexOutOfBoundsException e) { 630 // expected 631 } 632 633 try { 634 raf.write(byteArray, 0, 1); 635 fail("should throw IOException"); 636 } catch (IOException e) { 637 //expected 638 } 639 640 try { 641 raf.write(byteArray, 0, byteArray.length); 642 fail("should throw IOException"); 643 } catch (IOException e) { 644 //expected 645 } 646 647 try { 648 raf.write(byteArray, 1, 1); 649 fail("should throw IOException"); 650 } catch (IOException e) { 651 //expected 652 } 653 654 try { 655 raf.write(byteArray, byteArray.length + 1, 0); 656 fail("should throw IndexOutOfBoundsException"); 657 } catch (IndexOutOfBoundsException e) { 658 //expected 659 } 660 661 // will not throw IOException if count = 0 662 raf.write(byteArray, 0, 0); 663 raf.write(byteArray, byteArray.length, 0); 664 } 665 666 667 /** 668 * @tests java.io.RandomAccessFile#write(int) 669 */ 670 public void test_writeI() throws IOException { 671 // Test for method void java.io.RandomAccessFile.write(int) 672 byte[] rbuf = new byte[4000]; 673 RandomAccessFile raf = new java.io.RandomAccessFile(fileName, "rw"); 674 raf.write('t'); 675 raf.close(); 676 FileInputStream fis = new java.io.FileInputStream(fileName); 677 fis.read(rbuf, 0, 1); 678 assertEquals("Incorrect byte written", 't', rbuf[0]); 679 fis.close(); 680 } 681 682 /** 683 * @tests java.io.RandomAccessFile#writeBoolean(boolean) 684 */ 685 public void test_writeBooleanZ() throws IOException { 686 // Test for method void java.io.RandomAccessFile.writeBoolean(boolean) 687 RandomAccessFile raf = new java.io.RandomAccessFile(fileName, "rw"); 688 raf.writeBoolean(true); 689 raf.seek(0); 690 assertTrue("Incorrect boolean read/written", raf.readBoolean()); 691 raf.close(); 692 } 693 694 /** 695 * @tests java.io.RandomAccessFile#writeByte(int) 696 */ 697 public void test_writeByteI() throws IOException { 698 // Test for method void java.io.RandomAccessFile.writeByte(int) 699 RandomAccessFile raf = new java.io.RandomAccessFile(fileName, "rw"); 700 raf.writeByte(127); 701 raf.seek(0); 702 assertEquals("Incorrect byte read/written", 127, raf.readByte()); 703 raf.close(); 704 } 705 706 /** 707 * @tests java.io.RandomAccessFile#writeBytes(java.lang.String) 708 */ 709 public void test_writeBytesLjava_lang_String() throws IOException { 710 // Test for method void 711 // java.io.RandomAccessFile.writeBytes(java.lang.String) 712 byte[] buf = new byte[10]; 713 RandomAccessFile raf = new java.io.RandomAccessFile(fileName, "rw"); 714 raf.writeBytes("HelloWorld"); 715 raf.seek(0); 716 raf.readFully(buf); 717 assertEquals("Incorrect bytes read/written", "HelloWorld", new String( 718 buf, 0, 10, "UTF-8")); 719 raf.close(); 720 721 } 722 723 /** 724 * @tests java.io.RandomAccessFile#writeChar(int) 725 */ 726 public void test_writeCharI() throws IOException { 727 // Test for method void java.io.RandomAccessFile.writeChar(int) 728 RandomAccessFile raf = new java.io.RandomAccessFile(fileName, "rw"); 729 raf.writeChar('T'); 730 raf.seek(0); 731 assertEquals("Incorrect char read/written", 'T', raf.readChar()); 732 raf.close(); 733 } 734 735 /** 736 * @tests java.io.RandomAccessFile#writeChars(java.lang.String) 737 */ 738 public void test_writeCharsLjava_lang_String() throws IOException { 739 // Test for method void 740 // java.io.RandomAccessFile.writeChars(java.lang.String) 741 RandomAccessFile raf = new java.io.RandomAccessFile(fileName, "rw"); 742 raf.writeChars("HelloWorld"); 743 char[] hchars = new char[10]; 744 "HelloWorld".getChars(0, 10, hchars, 0); 745 raf.seek(0); 746 for (int i = 0; i < hchars.length; i++) 747 assertEquals("Incorrect string written", hchars[i], raf.readChar()); 748 raf.close(); 749 } 750 751 /** 752 * @tests java.io.RandomAccessFile#writeDouble(double) 753 */ 754 public void test_writeDoubleD() throws IOException { 755 // Test for method void java.io.RandomAccessFile.writeDouble(double) 756 RandomAccessFile raf = new java.io.RandomAccessFile(fileName, "rw"); 757 raf.writeDouble(Double.MAX_VALUE); 758 raf.seek(0); 759 assertEquals("Incorrect double read/written", Double.MAX_VALUE, raf 760 .readDouble(), 0); 761 raf.close(); 762 } 763 764 /** 765 * @tests java.io.RandomAccessFile#writeFloat(float) 766 */ 767 public void test_writeFloatF() throws IOException { 768 // Test for method void java.io.RandomAccessFile.writeFloat(float) 769 RandomAccessFile raf = new java.io.RandomAccessFile(fileName, "rw"); 770 raf.writeFloat(Float.MAX_VALUE); 771 raf.seek(0); 772 assertEquals("Incorrect float read/written", Float.MAX_VALUE, raf 773 .readFloat(), 0); 774 raf.close(); 775 } 776 777 /** 778 * @tests java.io.RandomAccessFile#writeInt(int) 779 */ 780 public void test_writeIntI() throws IOException { 781 // Test for method void java.io.RandomAccessFile.writeInt(int) 782 RandomAccessFile raf = new java.io.RandomAccessFile(fileName, "rw"); 783 raf.writeInt(Integer.MIN_VALUE); 784 raf.seek(0); 785 assertEquals("Incorrect int read/written", Integer.MIN_VALUE, raf 786 .readInt()); 787 raf.close(); 788 } 789 790 /** 791 * @tests java.io.RandomAccessFile#writeLong(long) 792 */ 793 public void test_writeLongJ() throws IOException { 794 // Test for method void java.io.RandomAccessFile.writeLong(long) 795 RandomAccessFile raf = new java.io.RandomAccessFile(fileName, "rw"); 796 raf.writeLong(Long.MAX_VALUE); 797 raf.seek(0); 798 assertEquals("Incorrect long read/written", Long.MAX_VALUE, raf 799 .readLong()); 800 raf.close(); 801 } 802 803 /** 804 * @tests java.io.RandomAccessFile#writeShort(int) 805 */ 806 public void test_writeShortI() throws IOException { 807 // Test for method void java.io.RandomAccessFile.writeShort(int) 808 RandomAccessFile raf = new java.io.RandomAccessFile(fileName, "rw"); 809 raf.writeShort(Short.MIN_VALUE); 810 raf.seek(0); 811 assertEquals("Incorrect long read/written", Short.MIN_VALUE, raf 812 .readShort()); 813 raf.close(); 814 } 815 816 /** 817 * @tests java.io.RandomAccessFile#writeUTF(java.lang.String) 818 */ 819 public void test_writeUTFLjava_lang_String() throws IOException { 820 // Test for method void 821 // java.io.RandomAccessFile.writeUTF(java.lang.String) 822 RandomAccessFile raf = new java.io.RandomAccessFile(fileName, "rw"); 823 raf.writeUTF(unihw); 824 raf.seek(0); 825 assertEquals("Incorrect utf string", unihw, raf.readUTF()); 826 raf.close(); 827 } 828 829 /** 830 * @tests java.io.RandomAccessFile#seek(long) 831 * 832 * Regression for HARMONY-374 833 */ 834 public void test_seekI() throws IOException { 835 RandomAccessFile raf = new java.io.RandomAccessFile(fileName, "rw"); 836 try { 837 raf.seek(-1); 838 fail("IOException must be thrown if pos < 0"); 839 } catch (IOException e) { 840 } 841 raf.close(); 842 } 843 844 /** 845 * @tests java.io.RandomAccessFile#read(byte[], int, int) 846 * 847 * Regression for HARMONY-377 848 */ 849 public void test_readBII() throws IOException { 850 RandomAccessFile raf = new java.io.RandomAccessFile(fileName, "rw"); 851 try { 852 raf.read(new byte[1], -1, 1); 853 fail("IndexOutOfBoundsException must be thrown if off <0"); 854 } catch (IndexOutOfBoundsException e) { 855 } 856 857 try { 858 raf.read(new byte[1], 0, -1); 859 fail("IndexOutOfBoundsException must be thrown if len <0"); 860 } catch (IndexOutOfBoundsException e) { 861 } 862 863 try { 864 raf.read(new byte[1], 0, 5); 865 fail("IndexOutOfBoundsException must be thrown if off+len > b.length"); 866 } catch (IndexOutOfBoundsException e) { 867 } 868 869 try { 870 raf.read(new byte[10], Integer.MAX_VALUE, 5); 871 fail("IndexOutOfBoundsException expected"); 872 } catch (IndexOutOfBoundsException e) { 873 } 874 875 try { 876 raf.read(new byte[10], 5, Integer.MAX_VALUE); 877 fail("IndexOutOfBoundsException expected"); 878 } catch (IndexOutOfBoundsException e) { 879 } 880 881 raf.close(); 882 } 883 884 /** 885 * @tests java.io.RandomAccessFile#read(byte[],int,int) 886 */ 887 public void test_read_$BII_IndexOutOfBoundsException() throws IOException { 888 FileOutputStream fos = new java.io.FileOutputStream(fileName); 889 fos.write(fileString.getBytes(), 0, fileString.length()); 890 fos.close(); 891 892 RandomAccessFile raf = new java.io.RandomAccessFile(fileName, "r"); 893 byte[] rbuf = new byte[100]; 894 raf.close(); 895 try { 896 raf.read(rbuf,-1,0); 897 fail("should throw IndexOutOfBoundsException"); 898 } catch (IndexOutOfBoundsException e) { 899 //expected 900 } 901 } 902 903 /** 904 * @tests java.io.RandomAccessFile#read(byte[],int,int) 905 */ 906 public void test_read_$BII_IOException() throws IOException { 907 FileOutputStream fos = new java.io.FileOutputStream(fileName); 908 fos.write(fileString.getBytes(), 0, fileString.length()); 909 fos.close(); 910 911 RandomAccessFile raf = new java.io.RandomAccessFile(fileName, "r"); 912 byte[] rbuf = new byte[100]; 913 raf.close(); 914 int read = raf.read(rbuf,0,0); 915 assertEquals(0,read); 916 } 917 918 /** 919 * @tests java.io.RandomAccessFile#read(byte[]) 920 */ 921 public void test_read_$B_IOException() throws IOException { 922 FileOutputStream fos = new java.io.FileOutputStream(fileName); 923 fos.write(fileString.getBytes(), 0, fileString.length()); 924 fos.close(); 925 926 RandomAccessFile raf = new java.io.RandomAccessFile(fileName, "r"); 927 byte[] rbuf = new byte[0]; 928 raf.close(); 929 int read = raf.read(rbuf); 930 assertEquals(0,read); 931 } 932 933 /** 934 * @tests java.io.RandomAccessFile#read(byte[],int,int) 935 */ 936 public void test_read_$BII_NullPointerException() throws IOException { 937 File f = File.createTempFile("tmp", "tmp"); 938 f.deleteOnExit(); 939 RandomAccessFile raf = new RandomAccessFile(f, "r"); 940 byte[] rbuf = null; 941 try { 942 raf.read(rbuf, 0, -1); 943 fail("should throw NullPointerException"); 944 } catch (NullPointerException e) { 945 // expected 946 } 947 raf.close(); 948 } 949 950 /** 951 * @tests java.io.RandomAccessFile#write(byte[], int, int) 952 * 953 * Regression for HARMONY-377 954 */ 955 public void test_writeBII() throws IOException { 956 RandomAccessFile raf = new java.io.RandomAccessFile(fileName, "rw"); 957 try { 958 raf.write(new byte[1], -1, 1); 959 fail("IndexOutOfBoundsException must be thrown if off <0"); 960 } catch (IndexOutOfBoundsException e) { 961 } 962 963 try { 964 raf.write(new byte[1], 0, -1); 965 fail("IndexOutOfBoundsException must be thrown if len <0"); 966 } catch (IndexOutOfBoundsException e) { 967 } 968 969 try { 970 raf.write(new byte[1], 0, 5); 971 fail("IndexOutOfBoundsException must be thrown if off+len > b.length"); 972 } catch (IndexOutOfBoundsException e) { 973 } 974 975 try { 976 raf.write(new byte[10], Integer.MAX_VALUE, 5); 977 fail("IndexOutOfBoundsException expected"); 978 } catch (IndexOutOfBoundsException e) { 979 } 980 981 try { 982 raf.write(new byte[10], 5, Integer.MAX_VALUE); 983 fail("IndexOutOfBoundsException expected"); 984 } catch (IndexOutOfBoundsException e) { 985 } 986 raf.close(); 987 } 988 989 /** 990 * Regression for HARMONY-69 991 */ 992 public void testRandomAccessFile_String_String() throws IOException { 993 f.createNewFile(); 994 RandomAccessFile raf = new java.io.RandomAccessFile(fileName, "r"); 995 FileChannel fcr = raf.getChannel(); 996 997 try { 998 fcr.lock(0L, Long.MAX_VALUE, false); 999 fail("NonWritableChannelException expected!"); 1000 } catch (NonWritableChannelException e) {} 1001 raf.close(); 1002 } 1003 1004 // Regression test for HARMONY-6542 1005 public void testRandomAccessFile_seekMoreThan2gb() throws IOException { 1006 if (File.separator != "/") { 1007 // skip windows until a test can be implemented that doesn't 1008 // require 2GB of free disk space 1009 return; 1010 } 1011 // (all?) unix platforms support sparse files so this should not 1012 // need to have 2GB free disk space to pass 1013 RandomAccessFile raf = new RandomAccessFile(f, "rw"); 1014 // write a few bytes so we get more helpful error messages 1015 // if we land in the wrong places 1016 raf.write(1); 1017 raf.write(2); 1018 raf.seek(2147483647); 1019 raf.write(3); 1020 raf.write(4); 1021 raf.write(5); 1022 raf.write(6); 1023 raf.seek(0); 1024 assertEquals("seek 0", 1, raf.read()); 1025 raf.seek(2147483649L); 1026 assertEquals("seek >2gb", 5, raf.read()); 1027 raf.seek(0); 1028 assertEquals("seek back to 0", 1, raf.read()); 1029 raf.close(); 1030 } 1031 1032 /** 1033 * Sets up the fixture, for example, open a network connection. This method 1034 * is called before a test is executed. 1035 */ 1036 protected void setUp() throws Exception { 1037 super.setUp(); 1038 f = File.createTempFile("raf", "tst"); 1039 if (!f.delete()) { 1040 fail("Unable to delete test file : " + f); 1041 } 1042 fileName = f.getAbsolutePath(); 1043 } 1044 1045 /** 1046 * Tears down the fixture, for example, close a network connection. This 1047 * method is called after a test is executed. 1048 * @throws Exception 1049 */ 1050 protected void tearDown() throws Exception { 1051 if (f.exists()) { 1052 f.delete(); 1053 } 1054 super.tearDown(); 1055 } 1056 1057} 1058