Make FileInputStream and FileOutputStream actually asynchronous.

tests/standalone/src/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");
 
 class MyListOfOneElement implements List {
   int _value;
@@ skipping 26 matching lines @@
   static void deleteTempDirectory() {
     tempDirectory.deleteSync(recursive: true);
   }
 
   // Test for file read functionality.
   static void testReadStream() {
     // Read a file and check part of it's contents.
     String filename = getFilename("bin/file_test.cc");
     File file = new File(filename);
     InputStream input = file.openInputStreamSync();
-    List<int> buffer = new List<int>(42);
-    int bytesRead = input.readInto(buffer, 0, 12);
-    Expect.equals(12, bytesRead);
-    bytesRead = input.readInto(buffer, 12, 30);
-    input.close();
-    Expect.equals(30, bytesRead);
-    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.
+    input.dataHandler = () {
+      List<int> buffer = new List<int>(42);
+      int bytesRead = input.readInto(buffer, 0, 12);
+      Expect.equals(12, bytesRead);
+      bytesRead = input.readInto(buffer, 12, 30);
+      input.close();
+      Expect.equals(30, bytesRead);
+      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.
+    };
   }
 
   // Test for file read and write functionality.
   static void testReadWriteStream() {
+    asyncTestStarted();
+
     // Read a file.
     String inFilename = getFilename("tests/vm/data/fixed_length_file");
     File file;
     InputStream input;
     int bytesRead;
 
     // Test reading all using readInto.
     file = new File(inFilename);
     input = file.openInputStreamSync();
-    List<int> buffer1 = new List<int>(42);
-    bytesRead = input.readInto(buffer1, 0, 42);
-    Expect.equals(42, bytesRead);
-    Expect.isTrue(input.closed);
+    input.dataHandler = () {
+      List<int> buffer1 = new List<int>(42);
+      bytesRead = input.readInto(buffer1, 0, 42);
+      Expect.equals(42, bytesRead);
+      Expect.isTrue(input.closed);
 
-    // Test reading all using readInto and read.
-    file = new File(inFilename);
-    input = file.openInputStreamSync();
-    bytesRead = input.readInto(buffer1, 0, 21);
-    Expect.equals(21, bytesRead);
-    buffer1 = input.read();
-    Expect.equals(21, buffer1.length);
-    Expect.isTrue(input.closed);
+      // Test reading all using readInto and read.
+      file = new File(inFilename);
+      input = file.openInputStreamSync();
+      input.dataHandler = () {
+        bytesRead = input.readInto(buffer1, 0, 21);
+        Expect.equals(21, bytesRead);
+        buffer1 = input.read();
+        Expect.equals(21, buffer1.length);
+        Expect.isTrue(input.closed);
 
-    // Test reading all using read and readInto.
-    file = new File(inFilename);
-    input = file.openInputStreamSync();
-    buffer1 = input.read(21);
-    Expect.equals(21, buffer1.length);
-    bytesRead = input.readInto(buffer1, 0, 21);
-    Expect.equals(21, bytesRead);
-    Expect.isTrue(input.closed);
+        // Test reading all using read and readInto.
+        file = new File(inFilename);
+        input = file.openInputStreamSync();
+        input.dataHandler = () {
+          buffer1 = input.read(21);
+          Expect.equals(21, buffer1.length);
+          bytesRead = input.readInto(buffer1, 0, 21);
+          Expect.equals(21, bytesRead);
+          Expect.isTrue(input.closed);
 
-    // Test reading all using read.
-    file = new File(inFilename);
-    input = file.openInputStreamSync();
-    buffer1 = input.read();
-    Expect.equals(42, buffer1.length);
-    Expect.isTrue(input.closed);
+          // Test reading all using read.
+          file = new File(inFilename);
+          input = file.openInputStreamSync();
+          input.dataHandler = () {
+            buffer1 = input.read();
+            Expect.equals(42, buffer1.length);
+            Expect.isTrue(input.closed);
 
-    // Write the contents of the file just read into another file.
-    String outFilename = tempDirectory.path + "/out_read_write_stream";
-    file = new File(outFilename);
-    OutputStream output = file.openOutputStreamSync();
-    bool writeDone = output.writeFrom(buffer1, 0, 42);
-    Expect.equals(true, writeDone);
-    output.close();
+            // Write the contents of the file just read into another file.
+            String outFilename = tempDirectory.path + "/out_read_write_stream";
+            file = new File(outFilename);
+            OutputStream output = file.openOutputStreamSync();
+            bool writeDone = output.writeFrom(buffer1, 0, 42);
+            Expect.equals(false, writeDone);
+            output.noPendingWriteHandler = () {
+              output.close();
 
-    // Now read the contents of the file just written.
-    List<int> buffer2 = new List<int>(42);
-    file = new File(outFilename);
-    input = file.openInputStreamSync();
-    bytesRead = input.readInto(buffer2, 0, 42);
-    Expect.isTrue(input.closed);
-    Expect.equals(42, bytesRead);
-    // Now compare the two buffers to check if they are identical.
-    for (int i = 0; i < buffer1.length; i++) {
-      Expect.equals(buffer1[i],  buffer2[i]);
-    }
-    // Delete the output file.
-    file.deleteSync();
-    Expect.isFalse(file.existsSync());
+              // Now read the contents of the file just written.
+              List<int> buffer2 = new List<int>(42);
+              file = new File(outFilename);
+              input = file.openInputStreamSync();
+              input.dataHandler = () {
+                bytesRead = input.readInto(buffer2, 0, 42);
+                Expect.isTrue(input.closed);
+                Expect.equals(42, bytesRead);
+                // Now compare the two buffers to check if they are identical.
+                for (int i = 0; i < buffer1.length; i++) {
+                  Expect.equals(buffer1[i],  buffer2[i]);
+                }
+                // Delete the output file.
+                file.deleteSync();
+                Expect.isFalse(file.existsSync());
+                asyncTestDone("testReadWriteStream");
+              };
+            };
+          };
+        };
+      };
+    };
   }
 
   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.errorHandler = (s) {
       Expect.fail("No errors expected : $s");
     };
     file.openHandler = (RandomAccessFile file) {
@@ skipping 157 matching lines @@
   }
 
   static void testOutputStreamWriteAppend() {
     String content = "foobar";
     String filename = tempDirectory.path + "/outstream_write_append";
     File file = new File(filename);
     file.createSync();
     List<int> buffer = content.charCodes();
     OutputStream outStream = file.openOutputStreamSync();
     outStream.write(buffer);
-    outStream.close();
-    File file2 = new File(filename);
-    OutputStream appendingOutput = file2.openOutputStreamSync(FileMode.APPEND);
-    appendingOutput.write(buffer);
-    appendingOutput.close();
-    File file3 = new File(filename);
-    file3.openHandler = (RandomAccessFile openedFile) {
-      openedFile.lengthHandler = (int length) {
-        Expect.equals(content.length * 2, length);
-        openedFile.closeHandler = () {
-          file3.deleteHandler = () {
-            asyncTestDone("testOutputStreamWriteAppend");
+    outStream.noPendingWriteHandler = () {
+      outStream.close();
+      File file2 = new File(filename);
+      OutputStream appendingOutput = file2.openOutputStreamSync(FileMode.APPEND);

[Søren Gjesse, 2012/02/28 07:40:25]

Long line.

[Mads Ager (google), 2012/02/28 08:21:00]

Done.

+      appendingOutput.write(buffer);
+      appendingOutput.noPendingWriteHandler = () {
+        appendingOutput.close();
+        File file3 = new File(filename);
+        file3.openHandler = (RandomAccessFile openedFile) {
+          openedFile.lengthHandler = (int length) {
+            Expect.equals(content.length * 2, length);
+            openedFile.closeHandler = () {
+              file3.deleteHandler = () {
+                asyncTestDone("testOutputStreamWriteAppend");
+              };
+              file3.delete();
+            };
+            openedFile.close();
           };
-          file3.delete();
+          openedFile.length();
         };
-        openedFile.close();
+        file3.open();
       };
-      openedFile.length();
     };
-    file3.open();
     asyncTestStarted();
   }
 
 
   static void testReadWriteSync() {
     // Read a file.
     String inFilename = getFilename("tests/vm/data/fixed_length_file");
     RandomAccessFile file = (new File(inFilename)).openSync();
     List<int> buffer1 = new List<int>(42);
     int bytes_read = 0;
@@ skipping 397 matching lines @@
     Expect.equals(true, !wrongExceptionCaught);
     input.deleteSync();
   }
 
   // Tests stream exception handling after file was closed.
   static void testCloseExceptionStream() {
     List<int> buffer = new List<int>(42);
     File file = new File(tempDirectory.path + "/out_close_exception_stream");
     file.createSync();
     InputStream input = file.openInputStreamSync();
-    Expect.isTrue(input.closed);
-    Expect.isNull(input.readInto(buffer, 0, 12));
-    OutputStream output = file.openOutputStreamSync();
-    output.close();
-    Expect.throws(( ) => output.writeFrom(buffer, 0, 12),
-                  (e) => e is FileIOException);
-    file.deleteSync();
+    input.closeHandler = () {
+      Expect.isTrue(input.closed);
+      Expect.isNull(input.readInto(buffer, 0, 12));
+      OutputStream output = file.openOutputStreamSync();
+      output.close();
+      Expect.throws(() => output.writeFrom(buffer, 0, 12));
+      file.deleteSync();
+    };
   }
 
   // Tests buffer out of bounds exception.
   static void testBufferOutOfBoundsException() {
     bool exceptionCaught = false;
     bool wrongExceptionCaught = false;
     File file = new File(tempDirectory.path + "/out_buffer_out_of_bounds");
     RandomAccessFile openedFile = file.openSync(FileMode.WRITE);
     try {
       List<int> buffer = new List<int>(10);
@@ skipping 223 matching lines @@
     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/readline_test1.dat");
     lines = new File(name).readAsLinesSync();
     Expect.equals(10, lines.length);
   }
 
+
   static void testReadAsErrors() {
+    var port = new ReceivePort.singleShot();
+    port.receive((message, _) {
+      Expect.equals(1, message);
+    });
     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);
-    // TODO(ager): Add tests of errors in readAsBytes when input
-    // streams are truely async.
+    f.readAsBytes();
+    f.errorHandler = (e) {
+      f.readAsText();
+      f.errorHandler = (e) {
+        f.readAsLines();
+        f.errorHandler = (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.openHandler = (openedFile) {
       openedFile.noPendingWriteHandler = () {
         openedFile.closeHandler = () {
           file.openHandler = (openedFile) {
@@ skipping 94 matching lines @@
       testWriteVariousLists();
       testDirectory();
       testDirectorySync();
     });
   }
 }
 
 main() {
   FileTest.testMain();
 }