Update dart:io tests to use asyncStart/asyncEnd

tests/standalone/io/file_test.dart

 // Copyright (c) 2013, 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 "package:expect/expect.dart";
-import "package:path/path.dart";
 import 'dart:async';
 import 'dart:convert';
 import 'dart:collection';
 import 'dart:io';
-import 'dart:isolate';
+
+import "package:async_helper/async_helper.dart";
+import "package:expect/expect.dart";
+import "package:path/path.dart";
 
 class MyListOfOneElement
     extends Object with ListMixin<int> implements List<int> {
   int _value;
   MyListOfOneElement(this._value);
   int get length => 1;
   operator [](int index) => _value;
   void set length(int index) { throw "Unsupported"; }
   operator []=(int index, value) {
     if (index != 0) {
       throw "Unsupported";
     } else {
       _value = value;
     }
   }
 }
 
 class FileTest {
   static Directory tempDirectory;
   static int numLiveAsyncTests = 0;
-  static ReceivePort port;
 
-  static void asyncTestStarted() { ++numLiveAsyncTests; }
+  static void asyncTestStarted() {
+    asyncStart();
+    ++numLiveAsyncTests;
+  }
   static void asyncTestDone(String name) {
+    asyncEnd();
     --numLiveAsyncTests;
     if (numLiveAsyncTests == 0) {
       deleteTempDirectory();
-      port.close();
     }
   }
 
   static void createTempDirectory(Function doNext) {
     new Directory('').createTemp().then((temp) {
       tempDirectory = temp;
       doNext();
     });
   }
 
@@ skipping 154 matching lines @@
           },
           onDone: () {
             Expect.equals(2 * buffer.length, position);
             outputFile.delete().then((ignore) { done.complete(); });
           });
       });
     return done.future;
   }
 
   static void testRead() {
-    ReceivePort port = new ReceivePort();
+    asyncStart();
     // Read a file and check part of it's contents.
     String filename = getFilename("bin/file_test.cc");
     File file = new File(filename);
     file.open(mode: READ).then((RandomAccessFile file) {
       List<int> buffer = new List<int>(10);
       file.readInto(buffer, 0, 5).then((bytes_read) {
         Expect.equals(5, bytes_read);
         file.readInto(buffer, 5, 10).then((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().then((ignore) => port.close());
+          file.close().then((ignore) => asyncEnd());
         });
       });
     });
   }
 
   static void testReadSync() {
     // Read a file and check part of it's contents.
     String filename = getFilename("bin/file_test.cc");
     RandomAccessFile raf = (new File(filename)).openSync();
     List<int> buffer = new List<int>(42);
@@ skipping 305 matching lines @@
             file2.deleteSync();
             asyncTestDone("testWriteVariousLists");
           });
         });
       });
     });
   }
 
   static void testDirectory() {
     asyncTestStarted();
-
-    // Port to verify that the test completes.
-    var port = new ReceivePort();
-    port.receive((message, replyTo) {
-      port.close();
-      Expect.equals(1, message);
-      asyncTestDone("testDirectory");
-    });
-
     var tempDir = tempDirectory.path;
     var file = new File("${tempDir}/testDirectory");
       file.create().then((ignore) {
           Directory d = file.directory;
           d.exists().then((xexists) {
           Expect.isTrue(xexists);
           Expect.isTrue(d.path.endsWith(tempDir));
-          file.delete().then((ignore) {
-                port.toSendPort().send(1);
-          });
+          file.delete().then((ignore) => asyncTestDone("testDirectory"));
         });
       });
   }
 
   static void testDirectorySync() {
     var tempDir = tempDirectory.path;
     var file = new File("${tempDir}/testDirectorySync");
     // Non-existing file still provides the directory.
     Expect.equals("${tempDir}", file.directory.path);
     file.createSync();
     // Check that the path of the returned directory is the temp directory.
     Directory d = file.directory;
     Expect.isTrue(d.existsSync());
     Expect.isTrue(d.path.endsWith(tempDir));
     file.deleteSync();
     // The directory getter does not care about file or type of file
     // system entity.
     Expect.equals("${tempDir}", file.directory.path);
     file = new File("foo");
     Expect.equals(".", file.directory.path);
     file = new File(".");
     Expect.equals(".", file.directory.path);
   }
 
   // Test for file length functionality.
   static void testLength() {
-    var port = new ReceivePort();
+    asyncTestStarted();
     String filename = getFilename("tests/vm/data/fixed_length_file");
     File file = new File(filename);
     RandomAccessFile openedFile = file.openSync();
     openedFile.length().then((length) {
       Expect.equals(42, length);
-      openedFile.close().then((ignore) => port.close());
+      openedFile.close().then((ignore) => asyncTestDone("testLength"));
     });
     file.length().then((length) {
       Expect.equals(42, length);
     });
   }
 
   static void testLengthSync() {
     String filename = getFilename("tests/vm/data/fixed_length_file");
     File file = new File(filename);
     RandomAccessFile openedFile = file.openSync();
     Expect.equals(42, file.lengthSync());
     Expect.equals(42, openedFile.lengthSync());
     openedFile.closeSync();
   }
 
   // Test for file position functionality.
   static void testPosition() {
-    var port = new ReceivePort();
+    asyncTestStarted();
     String filename = getFilename("tests/vm/data/fixed_length_file");
     RandomAccessFile input = (new File(filename)).openSync();
     input.position().then((position) {
       Expect.equals(0, position);
       List<int> buffer = new List<int>(100);
       input.readInto(buffer, 0, 12).then((bytes_read) {
         input.position().then((position) {
           Expect.equals(12, position);
           input.readInto(buffer, 12, 18).then((bytes_read) {
             input.position().then((position) {
               Expect.equals(18, position);
               input.setPosition(8).then((ignore) {
                 input.position().then((position) {
                   Expect.equals(8, position);
-                  input.close().then((ignore) => port.close());
+                  input.close().then((ignore) => asyncTestDone("testPosition"));
                 });
               });
             });
           });
         });
       });
     });
   }
 
   static void testPositionSync() {
@@ skipping 275 matching lines @@
     var name = getFilename("tests/vm/data/fixed_length_file");
     var f = new File(name);
     Expect.isTrue(f.existsSync());
     name = f.fullPathSync();
     var g = new File(name);
     Expect.isTrue(g.existsSync());
     Expect.equals(name, g.fullPathSync());
   }
 
   static void testReadAsBytes() {
-    var port = new ReceivePort();
-    port.receive((result, replyTo) {
-      port.close();
-      Expect.equals(42, result);
-    });
+    asyncTestStarted();
     var name = getFilename("tests/vm/data/fixed_length_file");
     var f = new File(name);
     f.readAsBytes().then((bytes) {
       Expect.isTrue(new String.fromCharCodes(bytes).endsWith("42 bytes."));
-      port.toSendPort().send(bytes.length);
+      Expect.equals(42, bytes.length);
+      asyncTestDone("testReadAsBytes");
     });
   }
 
   static void testReadAsBytesEmptyFile() {
-    var port = new ReceivePort();
-    port.receive((result, replyTo) {
-      port.close();
-      Expect.equals(0, result);
-    });
+    asyncTestStarted();
     var name = getFilename("tests/vm/data/empty_file");
     var f = new File(name);
     f.readAsBytes().then((bytes) {
-      port.toSendPort().send(bytes.length);
+      Expect.equals(0, bytes.length);
+      asyncTestDone("testReadAsBytesEmptyFile");
     });
   }
 
   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 testReadAsBytesSyncEmptyFile() {
     var name = getFilename("tests/vm/data/empty_file");
     var bytes = new File(name).readAsBytesSync();
     Expect.equals(bytes.length, 0);
   }
 
   static void testReadAsText() {
-    var port = new ReceivePort();
-    port.receive((result, replyTo) {
-      port.close();
-      Expect.equals(1, result);
-    });
+    asyncTestStarted();
     var name = getFilename("tests/vm/data/fixed_length_file");
     var f = new File(name);
     f.readAsString(encoding: UTF8).then((text) {
       Expect.isTrue(text.endsWith("42 bytes."));
       Expect.equals(42, text.length);
       var name = getDataFilename("tests/standalone/io/read_as_text.dat");
       var f = new File(name);
       f.readAsString(encoding: UTF8).then((text) {
         Expect.equals(6, text.length);
         var expected = [955, 120, 46, 32, 120, 10];
         Expect.listEquals(expected, text.codeUnits);
         f.readAsString(encoding: LATIN1).then((text) {
           Expect.equals(7, text.length);
           var expected = [206, 187, 120, 46, 32, 120, 10];
           Expect.listEquals(expected, text.codeUnits);
           var readAsStringFuture = f.readAsString(encoding: ASCII);
           readAsStringFuture.then((text) {
             Expect.fail("Non-ascii char should cause error");
           }).catchError((e) {
-            port.toSendPort().send(1);
+            asyncTestDone("testReadAsText");
           });
         });
       });
     });
   }
 
   static void testReadAsTextEmptyFile() {
-    var port = new ReceivePort();
-    port.receive((result, replyTo) {
-      port.close();
-      Expect.equals(0, result);
-    });
+    asyncTestStarted();
     var name = getFilename("tests/vm/data/empty_file");
     var f = new File(name);
     f.readAsString(encoding: UTF8).then((text) {
-      port.toSendPort().send(text.length);
+      Expect.equals(0, text.length);
+      asyncTestDone("testReadAsTextEmptyFile");
       return true;
     });
   }
 
   static void testReadAsTextSync() {
     var name = getFilename("tests/vm/data/fixed_length_file");
     var text = new File(name).readAsStringSync();
     Expect.isTrue(text.endsWith("42 bytes."));
     Expect.equals(42, text.length);
     name = getDataFilename("tests/standalone/io/read_as_text.dat");
@@ skipping 18 matching lines @@
     Expect.listEquals(expected, text.codeUnits);
   }
 
   static void testReadAsTextSyncEmptyFile() {
     var name = getFilename("tests/vm/data/empty_file");
     var text = new File(name).readAsStringSync();
     Expect.equals(0, text.length);
   }
 
   static void testReadAsLines() {
-    var port = new ReceivePort();
-    port.receive((result, replyTo) {
-      port.close();
-      Expect.equals(42, result);
-    });
+    asyncTestStarted();
     var name = getFilename("tests/vm/data/fixed_length_file");
     var f = new File(name);
     f.readAsLines(encoding: UTF8).then((lines) {
       Expect.equals(1, lines.length);
       var line = lines[0];
       Expect.isTrue(line.endsWith("42 bytes."));
-      port.toSendPort().send(line.length);
+      Expect.equals(42, line.length);
+      asyncTestDone("testReadAsLines");
     });
   }
 
   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/io/readline_test1.dat");
     lines = new File(name).readAsLinesSync();
     Expect.equals(10, lines.length);
   }
 
 
   static void testReadAsErrors() {
-    var port = new ReceivePort();
-    port.receive((message, _) {
-      port.close();
-      Expect.equals(1, message);
-    });
+    asyncTestStarted();
     var f = new File('.');
     Expect.throws(f.readAsBytesSync, (e) => e is FileException);
     Expect.throws(f.readAsStringSync, (e) => e is FileException);
     Expect.throws(f.readAsLinesSync, (e) => e is FileException);
     var readAsBytesFuture = f.readAsBytes();
     readAsBytesFuture.then((bytes) => Expect.fail("no bytes expected"))
     .catchError((e) {
       var readAsStringFuture = f.readAsString(encoding: UTF8);
       readAsStringFuture.then((text) => Expect.fail("no text expected"))
       .catchError((e) {
         var readAsLinesFuture = f.readAsLines(encoding: UTF8);
         readAsLinesFuture.then((lines) => Expect.fail("no lines expected"))
         .catchError((e) {
-          port.toSendPort().send(1);
+          asyncTestDone("testReadAsLines");
         });
       });
     });
   }
 
   static void testLastModified() {
-    var port = new ReceivePort();
+    asyncTestStarted();
     new File(Platform.executable).lastModified().then((modified) {
       Expect.isTrue(modified is DateTime);
       Expect.isTrue(modified.isBefore(new DateTime.now()));
-      port.close();
+      asyncTestDone("testLastModified");
     });
   }
 
   static void testLastModifiedSync() {
     var modified = new File(Platform.executable).lastModifiedSync();
     Expect.isTrue(modified is DateTime);
     Expect.isTrue(modified.isBefore(new DateTime.now()));
   }
 
   // Test that opens the same file for writing then for appending to test
@@ skipping 151 matching lines @@
   // Helper method to be able to run the test from the runtime
   // directory, or the top directory.
   static String getFilename(String path) =>
       new File(path).existsSync() ? path : 'runtime/$path';
 
   static String getDataFilename(String path) =>
       new File(path).existsSync() ? path : '../$path';
 
   // Main test entrypoint.
   static testMain() {
-    port = new ReceivePort();
     testRead();
     testReadSync();
     testReadStream();
     testLength();
     testLengthSync();
     testPosition();
     testPositionSync();
     testOpenDirectoryAsFile();
     testOpenDirectoryAsFileSync();
     testOpenFile();
@@ skipping 36 matching lines @@
       testWriteStringUtf8Sync();
       testRename();
       testRenameSync();
     });
   }
 }
 
 main() {
   FileTest.testMain();
 }