Add error handling to socket streams

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 134 matching lines @@
           };
         };
       };
     };
   }
 
   static void testRead() {
     // Read a file and check part of it's contents.
     String filename = getFilename("bin/file_test.cc");
     File file = new File(filename);
-    file.onError = (s) {
-      Expect.fail("No errors expected : $s");
+    file.onError = (e) {
+      Expect.fail("No errors expected : $e");
     };
     file.open(FileMode.READ, (RandomAccessFile file) {
       List<int> buffer = new List<int>(10);
       file.readList(buffer, 0, 5, (bytes_read) {
         Expect.equals(5, bytes_read);
         file.readList(buffer, 5, 5, (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.
@@ skipping 32 matching lines @@
     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.
   }
 
   // Test for file read and write functionality.
   static void testReadWrite() {
     // Read a file.
     String inFilename = getFilename("tests/vm/data/fixed_length_file");
     final File file = new File(inFilename);
-    file.onError = (s) {
-      Expect.fail("No errors expected : $s");
+    file.onError = (e) {
+      Expect.fail("No errors expected : $e");
     };
     file.open(FileMode.READ, (RandomAccessFile openedFile) {
       openedFile.onError = (s) {
         Expect.fail("No errors expected : $s");
       };
       List<int> buffer1 = new List<int>(42);
       openedFile.readList(buffer1, 0, 42, (bytes_read) {
         Expect.equals(42, bytes_read);
         openedFile.close(() {
           // Write the contents of the file just read into another file.
           String outFilename = tempDirectory.path + "/out_read_write";
           final File file2 = new File(outFilename);
-          file2.onError = (s) {
-            Expect.fail("No errors expected : $s");
+          file2.onError = (e) {
+            Expect.fail("No errors expected : $e");
           };
           file2.create(() {
             file2.fullPath((s) {
               Expect.isTrue(new File(s).existsSync());
               if (s[0] != '/' && s[0] != '\\' && s[1] != ':') {
                 Expect.fail("Not a full path");
               }
               file2.open(FileMode.WRITE, (RandomAccessFile openedFile2) {
                 openedFile2.onError = (s) {
                   Expect.fail("No errors expected : $s");
                 };
                 openedFile2.writeList(buffer1, 0, bytes_read);
                 openedFile2.onNoPendingWrites = () {
                   openedFile2.close(() {
                     List<int> buffer2 = new List<int>(bytes_read);
                     final File file3 = new File(outFilename);
-                    file3.onError = (s) {
-                      Expect.fail("No errors expected : $s");
+                    file3.onError = (e) {
+                      Expect.fail("No errors expected : $e");
                     };
                     file3.open(FileMode.READ, (RandomAccessFile openedFile3) {
                       openedFile3.onError = (s) {
                         Expect.fail("No errors expected : $s");
                       };
                       openedFile3.readList(buffer2, 0, 42, (bytes_read) {
                        Expect.equals(42, bytes_read);
                         openedFile3.close(() {
                           // Now compare the two buffers to check if they
                           // are identical.
@@ skipping 147 matching lines @@
     file.createSync();
     RandomAccessFile openedFile = file.openSync();
     Expect.throws(() => openedFile.readByteSync(), (e) => e is FileIOException);
     openedFile.closeSync();
     file.deleteSync();
   }
 
   static void testReadEmptyFile() {
     String fileName = tempDirectory.path + "/empty_file";
     File file = new File(fileName);
-    file.onError = (s) {
-      Expect.fail("No errors expected : $s");
+    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");
         });
         openedFile.onError = (String err) {
           Expect.isTrue(err.indexOf("failed") != -1);
           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 = (s) {
-      Expect.fail("No errors expected : $s");
+    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);
@@ skipping 36 matching lines @@
     port.receive((message, replyTo) {
       port.close();
       Expect.equals(1, message);
       asyncTestDone("testDirectory");
     });
 
     var tempDir = tempDirectory.path;
     var file = new File("${tempDir}/testDirectory");
     var errors = 0;
     file.directory((d) => Expect.fail("non-existing file"));
-    file.onError = (s) {
-      file.onError = (s) => Expect.fail("no error expected");
+    file.onError = (e) {
+      file.onError = (e) => Expect.fail("no error expected");
       file.create(() {
         file.directory((Directory d) {
           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 = (s) {
+              file_dir.onError = (e) {
                 var file_dir = new File(tempDir);
                 file_dir.directory((d) => Expect.fail("non-existing file"));
-                file_dir.onError = (s) {
+                file_dir.onError = (e) {
                   port.toSendPort().send(1);
                 };
               };
             });
           });
         });
       });
     };
   }
 
@@ skipping 74 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 = (error) {
-      Expect.fail("testTruncate: No errors expected");
+    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(() {
@@ skipping 229 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 = (s) {
-      Expect.fail("No errors expected");
+    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 43 matching lines @@
       port.close();
       Expect.equals(1, result);
     });
     var name = getFilename("tests/vm/data/fixed_length_file");
     var f = new File(name);
     f.readAsText(Encoding.UTF_8, (text) {
       Expect.isTrue(text.endsWith("42 bytes."));
       Expect.equals(42, text.length);
       var name = getDataFilename("tests/standalone/src/io/read_as_text.dat");
       var f = new File(name);
-      f.onError = (e) => Expect.fail("No errors expected");
+      f.onError = (e) => Expect.fail("No errors expected: $e");
       f.readAsText(Encoding.UTF_8, (text) {
         Expect.equals(6, text.length);
         var expected = [955, 120, 46, 32, 120, 10];
         Expect.listEquals(expected, text.charCodes());
         f.readAsText(Encoding.ISO_8859_1, (text) {
           Expect.equals(7, text.length);
           var expected = [206, 187, 120, 46, 32, 120, 10];
           Expect.listEquals(expected, text.charCodes());
           f.onError = (e) {
             port.toSendPort().send(1);
@@ skipping 176 matching lines @@
       testWriteVariousLists();
       testDirectory();
       testDirectorySync();
     });
   }
 }
 
 main() {
   FileTest.testMain();
 }