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