Update dart:io tests to use asyncStart/asyncEnd

tests/standalone/io/directory_test.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.
 //
 // Directory listing test.
 
-import "package:expect/expect.dart";
 import "dart:async";
 import "dart:io";
-import "dart:isolate";
+
+import "package:async_helper/async_helper.dart";
+import "package:expect/expect.dart";
 
 class DirectoryTest {
   static void testListing() {
     bool listedDir = false;
     bool listedFile = false;
 
     Directory directory = new Directory("").createTempSync();
     Directory subDirectory = new Directory("${directory.path}/subdir");
     Expect.isTrue('$directory'.contains(directory.path));
     Expect.isFalse(subDirectory.existsSync());
@@ skipping 23 matching lines @@
       Expect.equals(listedFile, recursive);
       Expect.isTrue(listedDir);
       listedFile = false;
       listedDir = false;
     }
 
     testSyncListing(true);
     testSyncListing(false);
     Expect.equals(f.fullPathSync(), fLong.fullPathSync());
 
-    var listingDonePort = new ReceivePort();
+    asyncStart();
     directory.list(recursive: true).listen(
         (FileSystemEntity entity) {
           if (entity is File) {
             var path = entity.path;
             listedFile = true;
             Expect.isTrue(path.contains(directory.path));
             Expect.isTrue(path.contains('subdir'));
             Expect.isTrue(path.contains('file.txt'));
           } else {
             var path = entity.path;
             Expect.isTrue(entity is Directory);
             listedDir = true;
             Expect.isTrue(path.contains(directory.path));
             Expect.isTrue(path.contains('subdir'));
           }
         },
         onDone: () {
           Expect.isTrue(listedDir, "directory not found");
           Expect.isTrue(listedFile, "file not found");
           directory.delete(recursive: true).then((ignore) {
             f.exists().then((exists) => Expect.isFalse(exists));
             directory.exists().then((exists) => Expect.isFalse(exists));
             subDirectory.exists().then((exists) => Expect.isFalse(exists));
-            listingDonePort.close();
+            asyncEnd();
           });
         });
 
     // Listing is asynchronous, so nothing should be listed at this
     // point.
     Expect.isFalse(listedDir);
     Expect.isFalse(listedFile);
   }
 
   static void testListingTailingPaths() {
@@ skipping 26 matching lines @@
       d.delete().then((ignore) {
         setupListerHandlers(d.list());
         setupListerHandlers(d.list(recursive: true));
       });
     });
   }
 
   static void testListTooLongName() {
     new Directory("").createTemp().then((d) {
       var errors = 0;
-      var port = new ReceivePort();
+      asyncStart();
       setupListHandlers(Stream<FileSystemEntity> stream) {
         stream.listen(
           (_) => Expect.fail("Listing of non-existing directory should fail"),
           onError: (error) {
             Expect.isTrue(error is DirectoryException);
             if (++errors == 2) {
               d.delete(recursive: true).then((_) {
-                port.close();
+                asyncEnd();
               });
             }
           });
       }
       var subDirName = 'subdir';
       var subDir = new Directory("${d.path}/$subDirName");
       subDir.create().then((ignore) {
         // Construct a long string of the form
         // 'tempdir/subdir/../subdir/../subdir'.
         var buffer = new StringBuffer();
@@ skipping 20 matching lines @@
 
     new Directory("").createTemp().then((d) {
       d.delete().then((ignore) {
         setupFutureHandlers(d.delete());
         setupFutureHandlers(d.delete(recursive: true));
       });
     });
   }
 
   static void testDeleteTooLongName() {
-    var port = new ReceivePort();
+    asyncStart();
     new Directory("").createTemp().then((d) {
       var subDirName = 'subdir';
       var subDir = new Directory("${d.path}/$subDirName");
       subDir.create().then((ignore) {
           // Construct a long string of the form
           // 'tempdir/subdir/../subdir/../subdir'.
           var buffer = new StringBuffer();
           buffer.write(subDir.path);
           for (var i = 0; i < 1000; i++) {
             buffer.write("/../${subDirName}");
           }
           var long = new Directory("${buffer.toString()}");
           var errors = 0;
           onError(error) {
             Expect.isTrue(error is DirectoryException);
             if (++errors == 2) {
-              d.delete(recursive: true).then((ignore) => port.close());
+              d.delete(recursive: true).then((_) => asyncEnd());
             }
             return true;
           }
           long.delete().catchError(onError);
           long.delete(recursive: true).catchError(onError);
         });
     });
   }
 
   static void testDeleteNonExistentSync() {
@@ skipping 145 matching lines @@
         },
         onDone: () {
           Expect.equals(2, count);
           l.deleteSync();
           d.deleteSync();
           tmp.deleteSync();
         });
   }
 
   static void testCreateTemp([String template = ""]) {
-    var port = new ReceivePort();
+    asyncStart();
     Directory dir = new Directory(template);
     Future.wait([dir.createTemp(), dir.createTemp()])
       .then((tempDirs) {
         Expect.notEquals(tempDirs[0].path, tempDirs[1].path);
         for (Directory t in tempDirs) {
           Expect.isTrue(t.existsSync());
           t.deleteSync();
           Expect.isFalse(t.existsSync());
         }
-        port.close();
+        asyncEnd();
       });
   }
 
   static void testCreateTempTemplate() {
     if (new Directory("/tmp").existsSync()) {
       testCreateTemp("/tmp/dart_temp_dir_");
     }
   }
 
   static void testCreateDeleteTemp() {
@@ skipping 115 matching lines @@
     Expect.throws(new Directory(location).createTempSync,
                   (e) => e is DirectoryException);
   }
 }
 
 
 testCreateTempError() {
   var location = illegalTempDirectoryLocation();
   if (location == null) return;
 
-  var port = new ReceivePort();
+  asyncStart();
   var future = new Directory(location).createTemp();
-  future.catchError((e) => port.close());
+  future.catchError((_) => asyncEnd());
 }
 
 
 testCreateExistingSync() {
   // Test that creating an existing directory succeeds.
   var d = new Directory('');
   var temp = d.createTempSync();
   var subDir = new Directory('${temp.path}/flaf');
   Expect.isFalse(subDir.existsSync());
   subDir.createSync();
   Expect.isTrue(subDir.existsSync());
   subDir.createSync();
   Expect.isTrue(subDir.existsSync());
   temp.deleteSync(recursive: true);
 }
 
 
 testCreateExisting() {
   // Test that creating an existing directory succeeds.
-  var port = new ReceivePort();
+  asyncStart();
   var d = new Directory('');
   d.createTemp().then((temp) {
     var subDir = new Directory('${temp.path}/flaf');
     subDir.exists().then((dirExists) {
       Expect.isFalse(dirExists);
       subDir.create().then((_) {
         subDir.exists().then((dirExists) {
           Expect.isTrue(dirExists);
           subDir.create().then((_) {
             subDir.exists().then((dirExists) {
               Expect.isTrue(dirExists);
               temp.delete(recursive: true).then((_) {
-                port.close();
+                asyncEnd();
               });
             });
           });
         });
       });
     });
   });
 }
 
 
 testCreateDirExistingFileSync() {
   // Test that creating an existing directory succeeds.
   var d = new Directory('');
   var temp = d.createTempSync();
   var path = '${temp.path}/flaf';
   var file = new File(path);
   file.createSync();
   Expect.isTrue(file.existsSync());
   Expect.throws(new Directory(path).createSync,
                 (e) => e is DirectoryException);
   temp.deleteSync(recursive: true);
 }
 
 
 testCreateDirExistingFile() {
   // Test that creating an existing directory succeeds.
-  var port = new ReceivePort();
+  asyncStart();
   var d = new Directory('');
   d.createTemp().then((temp) {
     var path = '${temp.path}/flaf';
     var file = new File(path);
     var subDir = new Directory(path);
     file.create().then((_) {
       subDir.create()
         .then((_) { Expect.fail("dir create should fail on existing file"); })
         .catchError((error) {
           Expect.isTrue(error is DirectoryException);
           temp.delete(recursive: true).then((_) {
-            port.close();
+            asyncEnd();
           });
         });
     });
   });
 }
 
 
 testCreateRecursiveSync() {
   var temp = new Directory('').createTempSync();
   var d = new Directory('${temp.path}/a/b/c');
   d.createSync(recursive: true);
   Expect.isTrue(new Directory('${temp.path}/a').existsSync());
   Expect.isTrue(new Directory('${temp.path}/a/b').existsSync());
   Expect.isTrue(new Directory('${temp.path}/a/b/c').existsSync());
   temp.deleteSync(recursive: true);
 }
 
 
 testCreateRecursive() {
-  var port = new ReceivePort();
+  asyncStart();
   new Directory('').createTemp().then((temp) {
     var d = new Directory('${temp.path}/a/b/c');
     d.create(recursive: true).then((_) {
       Expect.isTrue(new Directory('${temp.path}/a').existsSync());
       Expect.isTrue(new Directory('${temp.path}/a/b').existsSync());
       Expect.isTrue(new Directory('${temp.path}/a/b/c').existsSync());
       temp.deleteSync(recursive: true);
-      port.close();
+      asyncEnd();
     });
   });
 }
 
 
 testRename() {
   var d = new Directory('');
   var temp1 = d.createTempSync();
   var temp2 = d.createTempSync();
   var temp3 = temp1.renameSync(temp2.path);
@@ skipping 17 matching lines @@
   testCreateTempErrorSync();
   testCreateTempError();
   testCreateExistingSync();
   testCreateExisting();
   testCreateDirExistingFileSync();
   testCreateDirExistingFile();
   testCreateRecursive();
   testCreateRecursiveSync();
   testRename();
 }