Add error handling to directory

tests/standalone/src/io/DirectoryTest.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("dart:io");
 #import("dart:isolate");
 
 class DirectoryTest {
@@ skipping 27 matching lines @@
       Expect.isTrue(completed, "directory listing did not complete");
       Expect.isTrue(listedDir, "directory not found");
       Expect.isTrue(listedFile, "file not found");
       directory.deleteRecursively(() {
         f.exists((exists) => Expect.isFalse(exists));
         directory.exists((exists) => Expect.isFalse(exists));
         subDirectory.exists((exists) => Expect.isFalse(exists));
       });
     };
 
-    directory.onError = (error) {
-      Expect.fail("error listing directory: $error");
+    directory.onError = (e) {
+      Expect.fail("error listing directory: $e");
     };
 
     directory.list(recursive: true);
 
     // Listing is asynchronous, so nothing should be listed at this
     // point.
     Expect.isFalse(listedDir);
     Expect.isFalse(listedFile);
   }
 
   static void testListNonExistent() {
     Directory d = new Directory("");
-    d.onError = (error) {
-      Expect.fail("Directory error: $error");
+    d.onError = (e) {
+      Expect.fail("Directory error: $e");
     };
     d.createTemp(() {
       d.delete(() {
         // Test that listing a non-existing directory fails.
-        d.onError = (error) {
-          // TODO(ager): When directory errors have been changed to
-          // post back exceptions, check that we get the right exception
-          // type here.
+        d.onError = (e) {
+          Expect.isTrue(e is DirectoryIOException);
         };
         d.onFile = (file) {
           Expect.fail("Listing of non-existing directory should fail");
         };
         d.onDir = (dir) {
           Expect.fail("Listing of non-existing directory should fail");
         };
         d.onDone = (done) {
           Expect.isFalse(done);
         };
         d.list();
         d.list(recursive: true);
       });
     });
   }
 
   static void testListTooLongName() {
     Directory d = new Directory("");
-    d.onError = (error) {
-      Expect.fail("Directory error: $error");
+    d.onError = (e) {
+      Expect.fail("Directory error: $e");
     };
     d.createTemp(() {
       var subDirName = 'subdir';
       var subDir = new Directory("${d.path}/$subDirName");
-      subDir.onError = (error) {
-        Expect.fail("Directory error: $error");
+      subDir.onError = (e) {
+        Expect.fail("Directory error: $e");
       };
       subDir.create(() {
         // Construct a long string of the form
         // 'tempdir/subdir/../subdir/../subdir'.
         var buffer = new StringBuffer();
         buffer.add(subDir.path);
         for (var i = 0; i < 1000; i++) {
           buffer.add("/../${subDirName}");
         }
         var long = new Directory("${buffer.toString()}");
         var errors = 0;
-        long.onError = (error) {
-          // TODO(ager): When directory errors have been changed to
-          // post back exceptions, check that we get the right exception
-          // type here.
+        long.onError = (e) {
+          Expect.isTrue(e is DirectoryIOException);
           if (++errors == 2) {
             d.deleteRecursively(() => null);
           }
         };
         long.onFile = (file) {
           Expect.fail("Listing of non-existing directory should fail");
         };
         long.onDir = (dir) {
           Expect.fail("Listing of non-existing directory should fail");
         };
         long.onDone = (done) {
           Expect.isFalse(done);
         };
         long.list();
         long.list(recursive: true);
       });
     });
   }
 
   static void testDeleteNonExistent() {
     Directory d = new Directory("");
-    d.onError = (error) {
-      Expect.fail("Directory error: $error");
+    d.onError = (e) {
+      Expect.fail("Directory error: $e");
     };
     d.createTemp(() {
       d.delete(() {
         // Test that deleting a non-existing directory fails.
-        d.onError = (error) {
-          // TODO(ager): When directory errors have been changed to
-          // post back exceptions, check that we get the right exception
-          // type here.
+        d.onError = (e) {
+          Expect.isTrue(e is DirectoryIOException);
         };
         d.delete(() {
           Expect.fail("Deletion of non-existing directory should fail");
         });
         d.deleteRecursively(() {
           Expect.fail("Deletion of non-existing directory should fail");
         });
       });
     });
   }
 
   static void testDeleteTooLongName() {
     Directory d = new Directory("");
-    d.onError = (error) {
-      Expect.fail("Directory error: $error");
+    d.onError = (e) {
+      Expect.fail("Directory error: $e");
     };
     d.createTemp(() {
       var subDirName = 'subdir';
       var subDir = new Directory("${d.path}/$subDirName");
-      subDir.onError = (error) {
-        Expect.fail("Directory error: $error");
+      subDir.onError = (e) {
+        Expect.fail("Directory error: $e");
       };
       subDir.create(() {
         // Construct a long string of the form
         // 'tempdir/subdir/../subdir/../subdir'.
         var buffer = new StringBuffer();
         buffer.add(subDir.path);
         for (var i = 0; i < 1000; i++) {
           buffer.add("/../${subDirName}");
         }
         var long = new Directory("${buffer.toString()}");
         var errors = 0;
-        long.onError = (error) {
-          // TODO(ager): When directory errors have been changed to
-          // post back exceptions, check that we get the right exception
-          // type here.
+        long.onError = (e) {
+          Expect.isTrue(e is DirectoryIOException);
           if (++errors == 2) {
             d.deleteRecursively(() => null);
           }
         };
         long.delete(() {
           Expect.fail("Deletion of a directory with a long name should fail");
         });
         long.deleteRecursively(() {
           Expect.fail("Deletion of a directory with a long name should fail");
         });
@@ skipping 72 matching lines @@
     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;
     Function stage2;
     Function stage3;  // Loops to stage 0.
 
-    Function error(String message) {
-      Expect.fail("Directory onError: $message");
+    Function error(e) {
+      Expect.fail("Directory onError: $e");
     }
 
     stage0 = () {
       tempDir1.onError = error;
       tempDir1.createTemp(stage1a);
       tempDir2.onError = error;
       tempDir2.createTemp(stage1b);
     };
 
     stage1a = () {
@@ skipping 42 matching lines @@
     }
   }
 
   static void testCreateDeleteTemp() {
     Directory tempDirectory = new Directory("");
     tempDirectory.createTemp(() {
       String filename = tempDirectory.path +
           new Platform().pathSeparator() + "dart_testfile";
       File file = new File(filename);
       Expect.isFalse(file.existsSync());
-      file.onError = (error) {
-        Expect.fail("testCreateTemp file.onError called: $error");
+      file.onError = (e) {
+        Expect.fail("testCreateTemp file.onError called: $e");
       };
       file.create(() {
         file.exists((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(() {
@@ skipping 33 matching lines @@
   List<Directory> createdDirectories;
   Directory current;
 
   NestedTempDirectoryTest.run()
       : createdDirectories = new List<Directory>(),
         current = new Directory("") {
     current.onError = errorCallback;
     current.createTemp(createPhaseCallback);
   }
 
-  void errorCallback(error) {
-    Expect.fail("Error callback called in NestedTempDirectoryTest: $error");
+  void errorCallback(e) {
+    Expect.fail("Error callback called in NestedTempDirectoryTest: $e");
   }
 
   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}_");
@@ skipping 45 matching lines @@
   var location = illegalTempDirectoryLocation();
   if (location == null) return;
 
   var resultPort = new ReceivePort();
   resultPort.receive((String message, ignored) {
       resultPort.close();
       Expect.equals("error", message);
     });
 
   Directory dir = new Directory(location);
-  dir.onError = (error) { resultPort.toSendPort().send("error"); };
+  dir.onError = (e) { resultPort.toSendPort().send("error"); };
   dir.createTemp(() => resultPort.toSendPort().send("success"));
 }
 
 
 main() {
   DirectoryTest.testMain();
   NestedTempDirectoryTest.testMain();
   testCreateTempErrorSync();
   testCreateTempError();
 }