Merge IO v2 branch to bleeding edge

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 "dart:async";
 import "dart:io";
 import "dart:isolate";
 
@@ skipping 32 matching lines @@
       Expect.equals(listedFile, recursive);
       Expect.isTrue(listedDir);
       listedFile = false;
       listedDir = false;
     }
 
     testSyncListing(true);
     testSyncListing(false);
     Expect.equals(f.fullPathSync(), fLong.fullPathSync());
 
-    var lister = directory.list(recursive: true);
-
-    lister.onDir = (dir) {
-      listedDir = true;
-      Expect.isTrue(dir.contains(directory.path));
-      Expect.isTrue(dir.contains('subdir'));
-    };
-
-    lister.onFile = (f) {
-      listedFile = true;
-      Expect.isTrue(f.contains(directory.path));
-      Expect.isTrue(f.contains('subdir'));
-      Expect.isTrue(f.contains('file.txt'));
-    };
-
-    lister.onDone = (completed) {
-      Expect.isTrue(completed, "directory listing did not complete");
-      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));
-      });
-    };
+    var listingDonePort = new ReceivePort();
+    directory.list(recursive: true).listen(
+        (FileSystemEntity entity) {
+          if (entity is File) {
+            var path = entity.name;
+            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();
+          });
+        });
 
     // Listing is asynchronous, so nothing should be listed at this
     // point.
     Expect.isFalse(listedDir);
     Expect.isFalse(listedFile);
   }
 
   static void testListNonExistent() {
-    setupListerHandlers(DirectoryLister lister) {
-      // Test that listing a non-existing directory fails.
-      lister.onError = (e) {
-        Expect.isTrue(e is DirectoryIOException);
-      };
-      lister.onFile = (file) {
-        Expect.fail("Listing of non-existing directory should fail");
-      };
-      lister.onDir = (dir) {
-        Expect.fail("Listing of non-existing directory should fail");
-      };
-      lister.onDone = (success) {
-        Expect.isFalse(success);
-      };
+    setupListerHandlers(Stream<FileSystemEntity> stream) {
+      stream.listen(
+          (_) => Expect.fail("Listing of non-existing directory should fail"),
+          onError: (e) {
+            Expect.isTrue(e is AsyncError);
+            Expect.isTrue(e.error is DirectoryIOException);
+          });
     }
     new Directory("").createTemp().then((d) {
       d.delete().then((ignore) {
         setupListerHandlers(d.list());
         setupListerHandlers(d.list(recursive: true));
       });
     });
   }
 
   static void testListTooLongName() {
     new Directory("").createTemp().then((d) {
       var errors = 0;
-      setupListHandlers(DirectoryLister lister) {
-        lister.onError = (e) {
-          Expect.isTrue(e is DirectoryIOException);
-          if (++errors == 2) {
-            d.delete(recursive: true);
-          }
-        };
-        lister.onFile = (file) {
-          Expect.fail("Listing of non-existing directory should fail");
-        };
-        lister.onDir = (dir) {
-          Expect.fail("Listing of non-existing directory should fail");
-        };
-        lister.onDone = (success) {
-          Expect.isFalse(success);
-        };
+      var port = new ReceivePort();
+      setupListHandlers(Stream<FileSystemEntity> stream) {
+        stream.listen(
+          (_) => Expect.fail("Listing of non-existing directory should fail"),
+          onError: (e) {
+            Expect.isTrue(e is AsyncError);
+            Expect.isTrue(e.error is DirectoryIOException);
+            if (++errors == 2) {
+              d.delete(recursive: true).then((_) {
+                port.close();
+              });
+            }
+          });
       }
       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.add(subDir.path);
         for (var i = 0; i < 1000; i++) {
           buffer.add("/../${subDirName}");
@@ skipping 69 matching lines @@
     buffer.add(subDir.path);
     for (var i = 0; i < 1000; i++) {
       buffer.add("/../${subDirName}");
     }
     var long = new Directory("${buffer.toString()}");
     Expect.throws(long.deleteSync);
     Expect.throws(() => long.deleteSync(recursive: true));
     d.deleteSync(recursive: true);
   }
 
-  static void testDeleteSymlink() {
-    // temp/
-    //   a/
-    //     file.txt
-    //   b/
-    //     a_link -> a
-    var d = new Directory("").createTempSync();
-    var a = new Directory("${d.path}/a");
-    a.createSync();
-
-    var b = new Directory("${d.path}/b");
-    b.createSync();
-
-    var f = new File("${d.path}/a/file.txt");
-    f.createSync();
-    Expect.isTrue(f.existsSync());
-
-    // Create a symlink (or junction on Windows) from
-    // temp/b/a_link to temp/a.
-    var cmd = "ln";
-    var args = ['-s', "${d.path}/b/a_link", "${d.path}/a"];
-
-    if (Platform.operatingSystem == "windows") {
-      cmd = "cmd";
-      args = ["/c", "mklink", "/j", "${d.path}\\b\\a_link", "${d.path}\\a"];
-    }
-
-    Process.run(cmd, args).then((_) {
-      // Delete the directory containing the junction.
-      b.deleteSync(recursive: true);
-
-      // We should not have recursed through a_link into a.
-      Expect.isTrue(f.existsSync());
-
-      // Clean up after ourselves.
-      d.deleteSync(recursive: true);
-    });
-  }
-
   static void testExistsCreateDelete() {
     new Directory("").createTemp().then((d) {
       d.exists().then((bool exists) {
         Expect.isTrue(exists);
         Directory created = new Directory("${d.path}/subdir");
         created.create().then((ignore) {
           created.exists().then((bool exists) {
             Expect.isTrue(exists);
             created.delete().then((ignore) {
               created.exists().then((bool exists) {
@@ skipping 86 matching lines @@
   }
 
   static void testMain() {
     testListing();
     testListNonExistent();
     testListTooLongName();
     testDeleteNonExistent();
     testDeleteTooLongName();
     testDeleteNonExistentSync();
     testDeleteTooLongNameSync();
-    testDeleteSymlink();
     testExistsCreateDelete();
     testExistsCreateDeleteSync();
     testCreateTemp();
     testCreateDeleteTemp();
     testCurrent();
     testFromPath();
   }
 }
 
 
@@ skipping 194 matching lines @@
   testCreateTempErrorSync();
   testCreateTempError();
   testCreateExistingSync();
   testCreateExisting();
   testCreateDirExistingFileSync();
   testCreateDirExistingFile();
   testCreateRecursive();
   testCreateRecursiveSync();
   testRename();
 }