Add asynchronous versions of the methods on Directory.

tests/standalone/src/DirectoryTest.dart

 // Copyright (c) 2011, 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.
 
 class DirectoryTest {
   static void testListing() {
     bool listedDir = false;
     bool listedFile = false;
@@ skipping 36 matching lines @@
 
     directory.list(recursive: true);
 
     // Listing is asynchronous, so nothing should be listed at this
     // point.
     Expect.isFalse(listedDir);
     Expect.isFalse(listedFile);
   }
 
   static void testExistsCreateDelete() {
-    Directory d = new Directory("/tmp/dart_temp_dir_");
+    Directory d = new Directory("");
+    d.createTempHandler = () {
+      d.existsHandler = (bool exists) {
+        Expect.isTrue(exists);
+        Directory created = new Directory("${d.path}/subdir");
+        created.createHandler = () {
+          created.existsHandler = (bool exists) {
+            Expect.isTrue(exists);
+            created.deleteHandler = () {
+              created.existsHandler = (bool exists) {
+                Expect.isFalse(exists);
+                d.deleteHandler = () {
+                  d.existsHandler = (bool exists) {
+                    Expect.isFalse(exists);
+                  };
+                  d.exists();
+                };
+                d.delete();
+              };
+              created.exists();
+            };
+            created.delete();
+          };
+          created.exists();
+        };
+        created.create();
+      };
+      d.exists();
+    };
+    d.createTemp();
+  }
+
+  static void testExistsCreateDeleteSync() {
+    Directory d = new Directory("");
     d.createTempSync();
     Expect.isTrue(d.existsSync());
     Directory created = new Directory("${d.path}/subdir");
     created.createSync();
     Expect.isTrue(created.existsSync());
     created.deleteSync();
     Expect.isFalse(created.existsSync());
     d.deleteSync();
     Expect.isFalse(d.existsSync());
+  }
 
+  static void testCreateTemp() {
     Directory tempDir1 = new Directory("/tmp/dart_temp_dir_");
     Directory tempDir2 = new Directory("/tmp/dart_temp_dir_");
     bool stage1aDone = false;
     bool stage1bDone = false;
     bool emptyTemplateTestRunning = false;
 
     // Stages 0 through 2 run twice, the second time with an empty path.
     Function stage0;
     Function stage1a;
     Function stage1b;
@@ skipping 52 matching lines @@
     };
 
     if (new Directory("/tmp").existsSync()) {
       stage0();
     } else {
       emptyTemplateTestRunning = true;
       stage3();
     }
   }
 
-  static void testCreateTemp() {
+  static void testCreateDeleteTemp() {
     Directory tempDirectory = new Directory("");
     tempDirectory.createTempHandler = () {
       String filename = tempDirectory.path +
           new Platform().pathSeparator() + "dart_testfile";
       File file = new File(filename);
       Expect.isFalse(file.existsSync());
       file.errorHandler = (error) {
         Expect.fail("testCreateTemp file.errorHandler called: $error");
       };
       file.createHandler = () {
-        file.openHandler = (RandomAccessFile openedFile) {
-          openedFile.writeList([65, 66, 67, 13], 0, 4);
-          openedFile.noPendingWriteHandler = () {
-            openedFile.length();
-          };
-          openedFile.lengthHandler = (int length) {
-            Expect.equals(4, length);
-            openedFile.close();
-          };
-          openedFile.closeHandler = () {
-            file.exists();
-          };
-          file.existsHandler = (bool exists) {
-            Expect.isTrue(exists);
-            // Try to delete the directory containing the file - should throw.
-            bool threw_exception = false;
-            try {
-              tempDirectory.deleteSync();
-            } catch (var e) {
-              Expect.isTrue(tempDirectory.existsSync());
-              threw_exception = true;
-            }
-            Expect.isTrue(threw_exception);
-            Expect.isTrue(tempDirectory.existsSync());
+        file.existsHandler = (bool exists) {
+          Expect.isTrue(exists);
+          // Try to delete the directory containing the file - should throw.
+          Expect.throws(tempDirectory.deleteSync);
+          Expect.isTrue(tempDirectory.existsSync());
 
-            // Delete the file, and then delete the directory.
-            file.delete();
-          };
+          // Delete the file, and then delete the directory.
           file.deleteHandler = () {
             tempDirectory.deleteSync();
             Expect.isFalse(tempDirectory.existsSync());
           };
+          file.delete();
         };
-        file.open(writable: true);
+        file.exists();
       };
       file.create();
     };
     tempDirectory.createTemp();
   }
 
-  static void testNestedTempDirectory() {
-    var test = new NestedTempDirectoryTest();
-  }
-
-
   static void testMain() {
     testListing();
     testExistsCreateDelete();
+    testExistsCreateDeleteSync();
     testCreateTemp();
-    testNestedTempDirectory();
+    testCreateDeleteTemp();
   }
 }
 
 
 class NestedTempDirectoryTest {
   List<Directory> createdDirectories;
   Directory current;
 
-  NestedTempDirectoryTest(): createdDirectories = new List<Directory>();
+  NestedTempDirectoryTest.run()
+      : createdDirectories = new List<Directory>(),
+        current = new Directory("") {
+    current.createTempHandler = createPhaseCallback;
+    current.errorHandler = errorCallback;
+    current.createTemp();
+  }
 
   void errorCallback(error) {
     Expect.fail("Error callback called in NestedTempDirectoryTest: $error");
   }
 
   void createPhaseCallback() {
     createdDirectories.add(current);
     int nestingDepth = 6;
     var os = new Platform().operatingSystem();
     if (os == "windows") nestingDepth = 2;
     if (createdDirectories.length < nestingDepth) {
       current = new Directory(
           current.path + "/nested_temp_dir_${createdDirectories.length}_");
       current.errorHandler = errorCallback;
       current.createTempHandler = createPhaseCallback;
       current.createTemp();
     } else {
       deletePhaseCallback();
     }
   }
 
   void deletePhaseCallback() {
     if (!createdDirectories.isEmpty()) {
       current = createdDirectories.removeLast();
       current.deleteSync();
       deletePhaseCallback();
     }
   }
 
-  void startTest() {
-    current = new Directory("");
-    current.createTempHandler = createPhaseCallback;
-    current.errorHandler = errorCallback;
-    current.createTemp();
-  }
-
   static void testMain() {
-    new NestedTempDirectoryTest().startTest();
-    new NestedTempDirectoryTest().startTest();
+    new NestedTempDirectoryTest.run();
+    new NestedTempDirectoryTest.run();
   }
 }
 
 
 String illegalTempDirectoryLocation() {
   // Determine a platform specific illegal location for a temporary directory.
   var os = new Platform().operatingSystem();
   if (os == "linux" || os == "macos") {
     return "/dev/zero/";
   }
@@ skipping 28 matching lines @@
   dir.createTemp();
 }
 
 
 main() {
   DirectoryTest.testMain();
   NestedTempDirectoryTest.testMain();
   testCreateTempErrorSync();
   testCreateTempError();
 }