Split File into File and RandomAccessFile.

tests/standalone/src/FileTest.dart

 // Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 //
 // Dart test program for testing file I/O.
 
 
 class FileTest {
   static Directory tempDirectory;
   static int numLiveAsyncTests = 0;
@@ skipping 77 matching lines @@
     return 1;
   }
 
   static int testRead() {
     // Read a file and check part of it's contents.
     String filename = getFilename("bin/file_test.cc");
     File file = new File(filename);
     file.errorHandler = (s) {
       Expect.fail("No errors expected");
     };
-    file.openHandler = () {
+    file.openHandler = (RandomAccessFile file) {
       List<int> buffer = new List<int>(10);
       file.readListHandler = (bytes_read) {
         Expect.equals(5, bytes_read);
         file.readListHandler = (bytes_read) {
           Expect.equals(5, bytes_read);
           Expect.equals(47, buffer[0]);  // represents '/' in the file.
           Expect.equals(47, buffer[1]);  // represents '/' in the file.
           Expect.equals(32, buffer[2]);  // represents ' ' in the file.
           Expect.equals(67, buffer[3]);  // represents 'C' in the file.
           Expect.equals(111, buffer[4]);  // represents 'o' in the file.
           Expect.equals(112, buffer[5]);  // represents 'p' in the file.
           Expect.equals(121, buffer[6]);  // represents 'y' in the file.
           Expect.equals(114, buffer[7]);  // represents 'r' in the file.
           Expect.equals(105, buffer[8]);  // represents 'i' in the file.
           Expect.equals(103, buffer[9]);  // represents 'g' in the file.
           file.close();
         };
         file.readList(buffer, 5, 5);
       };
       file.readList(buffer, 0, 5);
     };
     file.open();
     return 1;
   }
 
   static int testReadSync() {
     // Read a file and check part of it's contents.
     String filename = getFilename("bin/file_test.cc");
-    File file = new File(filename);
-    file.openSync();
+    RandomAccessFile file = (new File(filename)).openSync();
     List<int> buffer = new List<int>(42);
     int bytes_read = 0;
     bytes_read = file.readListSync(buffer, 0, 12);
     Expect.equals(12, bytes_read);
     bytes_read = file.readListSync(buffer, 12, 30);
     Expect.equals(30, bytes_read);
     Expect.equals(47, buffer[0]);  // represents '/' in the file.
     Expect.equals(47, buffer[1]);  // represents '/' in the file.
     Expect.equals(32, buffer[2]);  // represents ' ' in the file.
     Expect.equals(67, buffer[3]);  // represents 'C' in the file.
     Expect.equals(111, buffer[4]);  // represents 'o' in the file.
     Expect.equals(112, buffer[5]);  // represents 'p' in the file.
     Expect.equals(121, buffer[6]);  // represents 'y' in the file.
     Expect.equals(114, buffer[7]);  // represents 'r' in the file.
     Expect.equals(105, buffer[8]);  // represents 'i' in the file.
     Expect.equals(103, buffer[9]);  // represents 'g' in the file.
     Expect.equals(104, buffer[10]);  // represents 'h' in the file.
     Expect.equals(116, buffer[11]);  // represents 't' in the file.
     return 1;
   }
 
   // Test for file read and write functionality.
   static int testReadWrite() {
     // Read a file.
     String inFilename = getFilename("tests/vm/data/fixed_length_file");
     File file = new File(inFilename);
     file.errorHandler = (s) {
       Expect.fail("No errors expected");
     };
-    file.openHandler = () {
+    file.openHandler = (RandomAccessFile openedFile) {
       List<int> buffer1 = new List<int>(42);
-      file.readListHandler = (bytes_read) {
+      openedFile.readListHandler = (bytes_read) {
         Expect.equals(42, bytes_read);
-        file.closeHandler = () {
+        openedFile.closeHandler = () {
           // Write the contents of the file just read into another file.
           String outFilename = tempDirectory.path + "/out_read_write";
           file = new File(outFilename);
           file.errorHandler = (s) {
             Expect.fail("No errors expected");
           };
           file.createHandler = () {
             file.fullPathHandler = (s) {
               Expect.isTrue(new File(s).existsSync());
               if (s[0] != '/' && s[0] != '\\' && s[1] != ':') {
                 Expect.fail("Not a full path");
               }
-              file.openHandler = () {
-                file.noPendingWriteHandler = () {
-                  file.closeHandler = () {
+              file.openHandler = (RandomAccessFile openedFile) {
+                openedFile.noPendingWriteHandler = () {
+                  openedFile.closeHandler = () {
                     // Now read the contents of the file just written.
                     List<int> buffer2 = new List<int>(bytes_read);
                     file = new File(outFilename);
                     file.errorHandler = (s) {
                       Expect.fail("No errors expected");
                     };
-                    file.openHandler = () {
-                      file.readListHandler = (bytes_read) {
+                    file.openHandler = (RandomAccessFile openedfile) {
+                      openedFile.readListHandler = (bytes_read) {
                         Expect.equals(42, bytes_read);
-                        file.closeHandler = () {
+                        openedFile.closeHandler = () {
                           // Now compare the two buffers to check if they
                           // are identical.
                           Expect.equals(buffer1.length, buffer2.length);
                           for (int i = 0; i < buffer1.length; i++) {
                             Expect.equals(buffer1[i],  buffer2[i]);
                           }
                           // Delete the output file.
                           file.deleteHandler = () {
                             file.existsHandler = (exists) {
                               Expect.isFalse(exists);
                               asyncTestDone();
                             };
                             file.exists();
                           };
                           file.delete();
                         };
-                        file.close();
+                        openedFile.close();
                       };
-                      file.readList(buffer2, 0, 42);
+                      openedFile.readList(buffer2, 0, 42);
                     };
                     file.open();
                   };
-                  file.close();
+                  openedFile.close();
                 };
-                file.writeList(buffer1, 0, bytes_read);
+                openedFile.writeList(buffer1, 0, bytes_read);
               };
               file.open(true);
             };
             file.fullPath();
           };
           file.create();
         };
-        file.close();
+        openedFile.close();
       };
-      file.readList(buffer1, 0, 42);
+      openedFile.readList(buffer1, 0, 42);
     };
     asyncTestStarted();
     file.open();
     return 1;
 
   }
 
   static int testReadWriteSync() {
     // Read a file.
     String inFilename = getFilename("tests/vm/data/fixed_length_file");
-    File file = new File(inFilename);
-    file.openSync();
+    RandomAccessFile file = (new File(inFilename)).openSync();
     List<int> buffer1 = new List<int>(42);
     int bytes_read = 0;
     int bytes_written = 0;
     bytes_read = file.readListSync(buffer1, 0, 42);
     Expect.equals(42, bytes_read);
     file.closeSync();
     // Write the contents of the file just read into another file.
     String outFilename = tempDirectory.path + "/out_read_write_sync";
-    file = new File(outFilename);
-    file.createSync();
-    String path = file.fullPathSync();
+    File outFile = new File(outFilename);
+    outFile.createSync();
+    String path = outFile.fullPathSync();
     if (path[0] != '/' && path[0] != '\\' && path[1] != ':') {
       Expect.fail("Not a full path");
     }
     Expect.isTrue(new File(path).existsSync());
-    file.openSync(true);
-    file.writeListSync(buffer1, 0, bytes_read);
-    file.closeSync();
+    RandomAccessFile openedFile = outFile.openSync(true);
+    openedFile.writeListSync(buffer1, 0, bytes_read);
+    openedFile.closeSync();
     // Now read the contents of the file just written.
     List<int> buffer2 = new List<int>(bytes_read);
-    file = new File(outFilename);
-    file.openSync();
-    bytes_read = file.readListSync(buffer2, 0, 42);
+    openedFile = (new File(outFilename)).openSync();
+    bytes_read = openedFile.readListSync(buffer2, 0, 42);
     Expect.equals(42, bytes_read);
-    file.closeSync();
+    openedFile.closeSync();
     // Now compare the two buffers to check if they are identical.
     Expect.equals(buffer1.length, buffer2.length);
     for (int i = 0; i < buffer1.length; i++) {
       Expect.equals(buffer1[i],  buffer2[i]);
     }
     // Delete the output file.
-    file.deleteSync();
-    Expect.isFalse(file.existsSync());
+    outFile.deleteSync();
+    Expect.isFalse(outFile.existsSync());
     return 1;
   }
 
   // Test for file length functionality.
   static int testLength() {
     String filename = getFilename("tests/vm/data/fixed_length_file");
-    File input = new File(filename);
+    RandomAccessFile input = (new File(filename)).openSync();
     input.errorHandler = (s) {
       Expect.fail("No errors expected");
     };
-    input.openSync();
     input.lengthHandler = (length) {
       Expect.equals(42, length);
       input.close();
     };
     input.length();
     return 1;
   }
 
   static int testLengthSync() {
     String filename = getFilename("tests/vm/data/fixed_length_file");
-    File input = new File(filename);
-    input.openSync();
+    RandomAccessFile input = (new File(filename)).openSync();
     Expect.equals(42, input.lengthSync());
     input.closeSync();
     return 1;
   }
 
   // Test for file position functionality.
   static int testPosition() {
     String filename = getFilename("tests/vm/data/fixed_length_file");
-    File input = new File(filename);
+    RandomAccessFile input = (new File(filename)).openSync();
     input.errorHandler = (s) {
       Expect.fail("No errors expected");
     };
-    input.openSync();
     input.positionHandler = (position) {
       Expect.equals(0, position);
       List<int> buffer = new List<int>(100);
       input.readListHandler = (bytes_read) {
         input.positionHandler = (position) {
           Expect.equals(12, position);
           input.readListHandler = (bytes_read) {
             input.positionHandler = (position) {
               Expect.equals(18, position);
               input.setPositionHandler = () {
@@ skipping 11 matching lines @@
         input.position();
       };
       input.readList(buffer, 0, 12);
     };
     input.position();
     return 1;
   }
 
   static int testPositionSync() {
     String filename = getFilename("tests/vm/data/fixed_length_file");
-    File input = new File(filename);
-    input.openSync();
+    RandomAccessFile input = (new File(filename)).openSync();
     Expect.equals(0, input.positionSync());
     List<int> buffer = new List<int>(100);
     input.readListSync(buffer, 0, 12);
     Expect.equals(12, input.positionSync());
     input.readListSync(buffer, 12, 6);
     Expect.equals(18, input.positionSync());
     input.setPositionSync(8);
     Expect.equals(8, input.positionSync());
     input.closeSync();
     return 1;
   }
 
   static int testTruncate() {
     File file = new File(tempDirectory.path + "/out_truncate");
     List buffer = const [65, 65, 65, 65, 65, 65, 65, 65, 65, 65];
     file.errorHandler = (error) {
       Expect.fail("testTruncate: No errors expected");
     };
-    file.openHandler = () {
-      file.noPendingWriteHandler = () {
-        file.lengthHandler = (length) {
+    file.openHandler = (RandomAccessFile openedFile) {
+      openedFile.noPendingWriteHandler = () {
+        openedFile.lengthHandler = (length) {
           Expect.equals(10, length);
-          file.truncateHandler = () {
-            file.lengthHandler = (length) {
+          openedFile.truncateHandler = () {
+            openedFile.lengthHandler = (length) {
               Expect.equals(5, length);
-              file.closeHandler = () {
+              openedFile.closeHandler = () {
                 file.deleteHandler = () {
                   file.existsHandler = (exists) {
                     Expect.isFalse(exists);
                     asyncTestDone();
                   };
                   file.exists();
                 };
                 file.delete();
               };
-              file.close();
+              openedFile.close();
             };
-            file.length();
+            openedFile.length();
           };
-          file.truncate(5);
+          openedFile.truncate(5);
         };
-        file.length();
+        openedFile.length();
       };
-      file.writeList(buffer, 0, 10);
+      openedFile.writeList(buffer, 0, 10);
     };
     asyncTestStarted();
     file.open(true);
     return 1;
   }
 
   static int testTruncateSync() {
     File file = new File(tempDirectory.path + "/out_truncate_sync");
     List buffer = const [65, 65, 65, 65, 65, 65, 65, 65, 65, 65];
-    file.openSync(true);
-    file.writeListSync(buffer, 0, 10);
-    Expect.equals(10, file.lengthSync());
-    file.truncateSync(5);
-    Expect.equals(5, file.lengthSync());
-    file.closeSync();
+    RandomAccessFile openedFile = file.openSync(true);
+    openedFile.writeListSync(buffer, 0, 10);
+    Expect.equals(10, openedFile.lengthSync());
+    openedFile.truncateSync(5);
+    Expect.equals(5, openedFile.lengthSync());
+    openedFile.closeSync();
     file.deleteSync();
     Expect.isFalse(file.existsSync());
     return 1;
   }
 
   // Tests exception handling after file was closed.
   static int testCloseException() {
     bool exceptionCaught = false;
     bool wrongExceptionCaught = false;
     File input = new File(tempDirectory.path + "/out_close_exception");
-    input.openSync(true);
-    input.closeSync();
+    RandomAccessFile openedFile = input.openSync(true);
+    openedFile.closeSync();
     try {
-      input.readByteSync();
+      openedFile.readByteSync();
     } catch (FileIOException ex) {
       exceptionCaught = true;
     } catch (Exception ex) {
       wrongExceptionCaught = true;
     }
     Expect.equals(true, exceptionCaught);
     Expect.equals(true, !wrongExceptionCaught);
     exceptionCaught = false;
     try {
-      input.writeByteSync(1);
+      openedFile.writeByteSync(1);
     } catch (FileIOException ex) {
       exceptionCaught = true;
     } catch (Exception ex) {
       wrongExceptionCaught = true;
     }
     Expect.equals(true, exceptionCaught);
     Expect.equals(true, !wrongExceptionCaught);
     exceptionCaught = false;
     try {
-      input.writeStringSync("Test");
+      openedFile.writeStringSync("Test");
     } catch (FileIOException ex) {
       exceptionCaught = true;
     } catch (Exception ex) {
       wrongExceptionCaught = true;
     }
     Expect.equals(true, exceptionCaught);
     Expect.equals(true, !wrongExceptionCaught);
     exceptionCaught = false;
     try {
       List<int> buffer = new List<int>(100);
-      input.readListSync(buffer, 0, 10);
+      openedFile.readListSync(buffer, 0, 10);
     } catch (FileIOException ex) {
       exceptionCaught = true;
     } catch (Exception ex) {
       wrongExceptionCaught = true;
     }
     Expect.equals(true, exceptionCaught);
     Expect.equals(true, !wrongExceptionCaught);
     exceptionCaught = false;
     try {
       List<int> buffer = new List<int>(100);
-      input.writeListSync(buffer, 0, 10);
+      openedFile.writeListSync(buffer, 0, 10);
     } catch (FileIOException ex) {
       exceptionCaught = true;
     } catch (Exception ex) {
       wrongExceptionCaught = true;
     }
     Expect.equals(true, exceptionCaught);
     Expect.equals(true, !wrongExceptionCaught);
     exceptionCaught = false;
     try {
-      input.positionSync();
+      openedFile.positionSync();
     } catch (FileIOException ex) {
       exceptionCaught = true;
     } catch (Exception ex) {
       wrongExceptionCaught = true;
     }
     Expect.equals(true, exceptionCaught);
     Expect.equals(true, !wrongExceptionCaught);
     exceptionCaught = false;
     try {
-      input.lengthSync();
+      openedFile.lengthSync();
     } catch (FileIOException ex) {
       exceptionCaught = true;
     } catch (Exception ex) {
       wrongExceptionCaught = true;
     }
     Expect.equals(true, exceptionCaught);
     Expect.equals(true, !wrongExceptionCaught);
     exceptionCaught = false;
     try {
-      input.flushSync();
+      openedFile.flushSync();
     } catch (FileIOException ex) {
       exceptionCaught = true;
     } catch (Exception ex) {
       wrongExceptionCaught = true;
     }
     Expect.equals(true, exceptionCaught);
     Expect.equals(true, !wrongExceptionCaught);
     input.deleteSync();
     return 1;
   }
@@ skipping 31 matching lines @@
     Expect.equals(true, !wrongExceptionCaught);
     file.deleteSync();
     return 1;
   }
 
   // Tests buffer out of bounds exception.
   static int testBufferOutOfBoundsException() {
     bool exceptionCaught = false;
     bool wrongExceptionCaught = false;
     File file = new File(tempDirectory.path + "/out_buffer_out_of_bounds");
-    file.openSync(true);
+    RandomAccessFile openedFile = file.openSync(true);
     try {
       List<int> buffer = new List<int>(10);
-      bool readDone = file.readListSync(buffer, 0, 12);
+      bool readDone = openedFile.readListSync(buffer, 0, 12);
     } catch (IndexOutOfRangeException ex) {
       exceptionCaught = true;
     } catch (Exception ex) {
       wrongExceptionCaught = true;
     }
     Expect.equals(true, exceptionCaught);
     Expect.equals(true, !wrongExceptionCaught);
     exceptionCaught = false;
     try {
       List<int> buffer = new List<int>(10);
-      bool readDone = file.readListSync(buffer, 6, 6);
+      bool readDone = openedFile.readListSync(buffer, 6, 6);
     } catch (IndexOutOfRangeException ex) {
       exceptionCaught = true;
     } catch (Exception ex) {
       wrongExceptionCaught = true;
     }
     Expect.equals(true, exceptionCaught);
     Expect.equals(true, !wrongExceptionCaught);
     exceptionCaught = false;
     try {
       List<int> buffer = new List<int>(10);
-      bool readDone = file.readListSync(buffer, -1, 1);
+      bool readDone = openedFile.readListSync(buffer, -1, 1);
     } catch (IndexOutOfRangeException ex) {
       exceptionCaught = true;
     } catch (Exception ex) {
       wrongExceptionCaught = true;
     }
     Expect.equals(true, exceptionCaught);
     Expect.equals(true, !wrongExceptionCaught);
     exceptionCaught = false;
     try {
       List<int> buffer = new List<int>(10);
-      bool readDone = file.readListSync(buffer, 0, -1);
+      bool readDone = openedFile.readListSync(buffer, 0, -1);
     } catch (IndexOutOfRangeException ex) {
       exceptionCaught = true;
     } catch (Exception ex) {
       wrongExceptionCaught = true;
     }
     Expect.equals(true, exceptionCaught);
     Expect.equals(true, !wrongExceptionCaught);
     exceptionCaught = false;
     try {
       List<int> buffer = new List<int>(10);
-      bool readDone = file.writeListSync(buffer, 0, 12);
+      bool readDone = openedFile.writeListSync(buffer, 0, 12);
     } catch (IndexOutOfRangeException ex) {
       exceptionCaught = true;
     } catch (Exception ex) {
       wrongExceptionCaught = true;
     }
     Expect.equals(true, exceptionCaught);
     Expect.equals(true, !wrongExceptionCaught);
     exceptionCaught = false;
     try {
       List<int> buffer = new List<int>(10);
-      bool readDone = file.writeListSync(buffer, 6, 6);
+      bool readDone = openedFile.writeListSync(buffer, 6, 6);
     } catch (IndexOutOfRangeException ex) {
       exceptionCaught = true;
     } catch (Exception ex) {
       wrongExceptionCaught = true;
     }
     Expect.equals(true, exceptionCaught);
     Expect.equals(true, !wrongExceptionCaught);
     exceptionCaught = false;
     try {
       List<int> buffer = new List<int>(10);
-      bool readDone = file.writeListSync(buffer, -1, 1);
+      bool readDone = openedFile.writeListSync(buffer, -1, 1);
     } catch (IndexOutOfRangeException ex) {
       exceptionCaught = true;
     } catch (Exception ex) {
       wrongExceptionCaught = true;
     }
     Expect.equals(true, exceptionCaught);
     Expect.equals(true, !wrongExceptionCaught);
     exceptionCaught = false;
     try {
       List<int> buffer = new List<int>(10);
-      bool readDone = file.writeListSync(buffer, 0, -1);
+      bool readDone = openedFile.writeListSync(buffer, 0, -1);
     } catch (IndexOutOfRangeException ex) {
       exceptionCaught = true;
     } catch (Exception ex) {
       wrongExceptionCaught = true;
     }
     Expect.equals(true, exceptionCaught);
     Expect.equals(true, !wrongExceptionCaught);
-    file.closeSync();
+    openedFile.closeSync();
     file.deleteSync();
     return 1;
   }
 
   static int testMixedSyncAndAsync() {
     var name = getFilename("tests/vm/data/fixed_length_file");
     var f = new File(name);
     f.errorHandler = (s) {
       Expect.fail("No errors expected");
     };
@@ skipping 35 matching lines @@
         Expect.equals(1, testCloseExceptionStream());
         Expect.equals(1, testBufferOutOfBoundsException());
         asyncTestDone();
       });
   }
 }
 
 main() {
   FileTest.testMain();
 }