Add error handling to random access file

tests/standalone/src/io/FileTest.dart

 // Copyright (c) 2012, 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.
 
 #import("dart:io");
 #import("dart:isolate");
 
 class MyListOfOneElement implements List {
@@ skipping 381 matching lines @@
     // Delete the output file.
     outFile.deleteSync();
     Expect.isFalse(outFile.existsSync());
   }
 
   static void testReadEmptyFileSync() {
     String fileName = tempDirectory.path + "/empty_file_sync";
     File file = new File(fileName);
     file.createSync();
     RandomAccessFile openedFile = file.openSync();
-    Expect.throws(() => openedFile.readByteSync(), (e) => e is FileIOException);
+    Expect.equals(-1, openedFile.readByteSync());
     openedFile.closeSync();
     file.deleteSync();
   }
 
   static void testReadEmptyFile() {
     String fileName = tempDirectory.path + "/empty_file";
     File file = new File(fileName);
     file.onError = (e) {
       Expect.fail("No errors expected : $e");
     };
     asyncTestStarted();
     file.create(() {
       file.open(FileMode.READ, (RandomAccessFile openedFile) {
         openedFile.readByte((int byte) {
-          Expect.fail("Read byte from empty file");
+          Expect.equals(-1, byte);
         });
-        openedFile.onError = (String err) {
-          Expect.isTrue(err.indexOf("failed") != -1);
+        openedFile.onError = (e) {
+          Expect.isTrue(e is FileIOException);
           openedFile.close(() {
             file.delete(() {
               asyncTestDone("testReadEmptyFile");
             });
           });
         };
       });
     });
   }
 
   // Test for file write of different types of lists.
   static void testWriteVariousLists() {
     asyncTestStarted();
     final String fileName = "${tempDirectory.path}/testWriteVariousLists";
     final File file = new File(fileName);
-    file.onError = (e) {
-      Expect.fail("No errors expected : $e");
-    };
+    file.onError = (e) => Expect.fail("No errors expected : $e");
     file.create(() {
       file.open(FileMode.WRITE, (RandomAccessFile openedFile) {
         // Write bytes from 0 to 7.
         openedFile.writeList([0], 0, 1);
         openedFile.writeList(const [1], 0, 1);
         openedFile.writeList(new MyListOfOneElement(2), 0, 1);
         var x = 12345678901234567890123456789012345678901234567890;
         var y = 12345678901234567890123456789012345678901234567893;
         openedFile.writeList([y - x], 0, 1);
         openedFile.writeList([260], 0, 1);  // 260 = 256 + 4 = 0x104.
         openedFile.writeList(const [261], 0, 1);
         openedFile.writeList(new MyListOfOneElement(262), 0, 1);
         x = 12345678901234567890123456789012345678901234567890;
         y = 12345678901234567890123456789012345678901234568153;
         openedFile.writeList([y - x], 0, 1);
 
-        openedFile.onError = (s) {
-          Expect.fail("No errors expected : $s");
-        };
+        openedFile.onError = (e) => Expect.fail("No errors expected : $e");
         openedFile.onNoPendingWrites = () {
           openedFile.close(() {
             // Check the written bytes.
             final File file2 = new File(fileName);
             var openedFile2 = file2.openSync();
             var length = openedFile2.lengthSync();
             Expect.equals(8, length);
             List data = new List(length);
             openedFile2.readListSync(data, 0, length);
             for (var i = 0; i < data.length; i++) {
@@ skipping 30 matching lines @@
           d.onError = (s) => Expect.fail("no error expected");
           d.exists((exists) {
             Expect.isTrue(exists);
             Expect.isTrue(d.path.endsWith(tempDir));
             file.delete(() {
               var file_dir = new File(".");
               file_dir.directory((d) => Expect.fail("non-existing file"));
               file_dir.onError = (e) {
                 var file_dir = new File(tempDir);
                 file_dir.directory((d) => Expect.fail("non-existing file"));
-                file_dir.onError = (e) {
-                  port.toSendPort().send(1);
-                };
+                file_dir.onError = (e) => port.toSendPort().send(1);
               };
             });
           });
         });
       });
     };
   }
 
   static void testDirectorySync() {
     var tempDir = tempDirectory.path;
@@ skipping 10 matching lines @@
     var file_dir = new File(".");
     Expect.throws(file_dir.directorySync, (e) { return e is FileIOException; });
     file_dir = new File(tempDir);
     Expect.throws(file_dir.directorySync, (e) { return e is FileIOException; });
   }
 
   // Test for file length functionality.
   static void testLength() {
     String filename = getFilename("tests/vm/data/fixed_length_file");
     RandomAccessFile input = (new File(filename)).openSync();
-    input.onError = (s) {
-      Expect.fail("No errors expected");
-    };
+    input.onError = (e) => Expect.fail("No errors expected");
     input.length((length) {
       Expect.equals(42, length);
       input.close(() => null);
     });
   }
 
   static void testLengthSync() {
     String filename = getFilename("tests/vm/data/fixed_length_file");
     RandomAccessFile input = (new File(filename)).openSync();
     Expect.equals(42, input.lengthSync());
     input.closeSync();
   }
 
   // Test for file position functionality.
   static void testPosition() {
     String filename = getFilename("tests/vm/data/fixed_length_file");
     RandomAccessFile input = (new File(filename)).openSync();
-    input.onError = (s) {
-      Expect.fail("No errors expected");
-    };
+    input.onError = (e) => Expect.fail("No errors expected");
     input.position((position) {
       Expect.equals(0, position);
       List<int> buffer = new List<int>(100);
       input.readList(buffer, 0, 12, (bytes_read) {
         input.position((position) {
           Expect.equals(12, position);
           input.readList(buffer, 12, 6, (bytes_read) {
             input.position((position) {
               Expect.equals(18, position);
               input.setPosition(8, () {
@@ skipping 19 matching lines @@
     input.readListSync(buffer, 12, 6);
     Expect.equals(18, input.positionSync());
     input.setPositionSync(8);
     Expect.equals(8, input.positionSync());
     input.closeSync();
   }
 
   static void testTruncate() {
     File file = new File(tempDirectory.path + "/out_truncate");
     List buffer = const [65, 65, 65, 65, 65, 65, 65, 65, 65, 65];
-    file.onError = (e) {
-      Expect.fail("No errors expected: $e");
-    };
+    file.onError = (e) => Expect.fail("No errors expected: $e");
     file.open(FileMode.WRITE, (RandomAccessFile openedFile) {
       openedFile.writeList(buffer, 0, 10);
       openedFile.onNoPendingWrites = () {
         openedFile.length((length) {
           Expect.equals(10, length);
           openedFile.truncate(5, () {
             openedFile.length((length) {
               Expect.equals(5, length);
               openedFile.close(() {
                 file.delete(() {
@@ skipping 228 matching lines @@
     }
     Expect.equals(true, exceptionCaught);
     Expect.equals(true, !wrongExceptionCaught);
     openedFile.closeSync();
     file.deleteSync();
   }
 
   static void testMixedSyncAndAsync() {
     var name = getFilename("tests/vm/data/fixed_length_file");
     var f = new File(name);
-    f.onError = (e) {
-      Expect.fail("No errors expected: $e");
-    };
+    f.onError = (e) => Expect.fail("No errors expected: $e");
     f.exists((exists) {
       try {
         f.existsSync();
         Expect.fail("Expected exception");
       } catch (var e) {
         Expect.isTrue(e is FileIOException);
       }
     });
   }
 
@@ skipping 17 matching lines @@
     port.receive((result, replyTo) {
       port.close();
       Expect.equals(42, result);
     });
     var name = getFilename("tests/vm/data/fixed_length_file");
     var f = new File(name);
     f.readAsBytes((bytes) {
       Expect.isTrue(new String.fromCharCodes(bytes).endsWith("42 bytes."));
       port.toSendPort().send(bytes.length);
     });
-    f.onError = (e) {
-      Expect.fail("No errors expected: $e");
-    };
+    f.onError = (e) => Expect.fail("No errors expected: $e");
   }
 
   static void testReadAsBytesSync() {
     var name = getFilename("tests/vm/data/fixed_length_file");
     var bytes = new File(name).readAsBytesSync();
     Expect.isTrue(new String.fromCharCodes(bytes).endsWith("42 bytes."));
     Expect.equals(bytes.length, 42);
   }
 
   static void testReadAsText() {
@@ skipping 56 matching lines @@
       Expect.equals(42, result);
     });
     var name = getFilename("tests/vm/data/fixed_length_file");
     var f = new File(name);
     f.readAsLines(Encoding.UTF_8, (lines) {
       Expect.equals(1, lines.length);
       var line = lines[0];
       Expect.isTrue(line.endsWith("42 bytes."));
       port.toSendPort().send(line.length);
     });
-    f.onError = (e) {
-      Expect.fail("No errors expected: $e");
-    };
+    f.onError = (e) => Expect.fail("No errors expected: $e");
   }
 
   static void testReadAsLinesSync() {
     var name = getFilename("tests/vm/data/fixed_length_file");
     var lines = new File(name).readAsLinesSync();
     Expect.equals(1, lines.length);
     var line = lines[0];
     Expect.isTrue(line.endsWith("42 bytes."));
     Expect.equals(42, line.length);
     name = getDataFilename("tests/standalone/src/io/readline_test1.dat");
@@ skipping 11 matching lines @@
     var f = new File('.');
     Expect.throws(f.readAsBytesSync, (e) => e is FileIOException);
     Expect.throws(f.readAsTextSync, (e) => e is FileIOException);
     Expect.throws(f.readAsLinesSync, (e) => e is FileIOException);
     f.readAsBytes((bytes) => Expect.fail("no bytes expected"));
     f.onError = (e) {
       f.readAsText(Encoding.UTF_8, (text) => Expect.fail("no text expected"));
       f.onError = (e) {
         f.readAsLines(Encoding.UTF_8,
                       (lines) => Expect.fail("no lines expected"));
-        f.onError = (e) {
-          port.toSendPort().send(1);
-        };
+        f.onError = (e) => port.toSendPort().send(1);
       };
     };
   }
 
   // Test that opens the same file for writing then for appending to test
   // that the file is not truncated when opened for appending.
   static void testAppend() {
     var file = new File('${tempDirectory.path}/out_append');
     file.open(FileMode.WRITE, (openedFile) {
       openedFile.writeString("asdf");
@@ skipping 86 matching lines @@
       testWriteVariousLists();
       testDirectory();
       testDirectorySync();
     });
   }
 }
 
 main() {
   FileTest.testMain();
 }