dart:io | Add "followLinks" optional parameter to Directory.list, let it return Link objects when f…

tests/standalone/io/link_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.
 
+import "dart:async";
 import "dart:io";
 import "dart:isolate";
 
 // Test the dart:io Link class.
 
 testCreateSync() {
   Path base = new Path(new Directory('').createTempSync().path);
   String link = base.append('link').toNativePath();
   String target = base.append('target').toNativePath();
   new Directory(target).createSync();
@@ skipping 54 matching lines @@
 
   String createdFile = base.append('target/createdFile').toNativePath();
   new File(createdFile).createSync();
   Expect.isTrue(FileSystemEntity.identicalSync(createdFile, createdFile));
   Expect.isFalse(FileSystemEntity.identicalSync(createdFile, createdDirectly));
   Expect.isTrue(FileSystemEntity.identicalSync(createdFile,
       base.append('link/createdFile').toNativePath()));
   Expect.throws(() => FileSystemEntity.identicalSync(createdFile,
       base.append('link/foo').toNativePath()));
 
-  new Directory.fromPath(base).deleteSync(recursive: true);
+  var baseDir = new Directory.fromPath(base);
+
+  Map makeExpected(bool recursive, bool followLinks) {
+    Map expected = new Map();
+    expected['target'] = 'Directory';
+    expected['link'] = followLinks ? 'Directory' : 'Link';
+    if (recursive) {
+      expected['target/createdDirectly'] = 'Directory';
+      expected['target/createdThroughLink'] = 'Directory';
+      expected['target/createdFile'] = 'File';
+      if (followLinks) {
+        expected['link/createdDirectly'] = 'Directory';
+        expected['link/createdThroughLink'] = 'Directory';
+        expected['link/createdFile'] = 'File';
+      }
+    }
+    return expected;
+  }
+
+  void checkEntity(FileSystemEntity x, Map expected) {
+    String ending = new Path(x.path).relativeTo(base).toString();
+    Expect.isNotNull(expected[ending]);
+    Expect.isTrue(x.toString().startsWith(expected[ending]));
+    expected[ending] = 'Found';
+  }
+
+  List futures = [];
+  for (bool recursive in [true, false]) {
+    for (bool followLinks in [true, false]) {
+      Map expected = makeExpected(recursive, followLinks);
+      for (var x in baseDir.listSync(recursive: recursive,
+                                 followLinks: followLinks)) {

[Bill Hesse, 2013/03/21 18:36:44]

Indentation.

+        checkEntity(x, expected);
+      }
+      for (var v in expected.values) {
+        Expect.equals('Found', v);
+      }
+      expected = makeExpected(recursive, followLinks);
+      futures.add(
+          baseDir.list(recursive: recursive, followLinks: followLinks).reduce(

[Bill Hesse, 2013/03/21 18:36:44]

Use Stream.reduce to call a function with each event, and complete a future when
done.

[Søren Gjesse, 2013/03/22 08:07:35]

Run the same tests for listSync.

[Bill Hesse, 2013/03/22 09:58:55]

I do!  It is just so small you missed it - lines 109-115.

[Bill Hesse, 2013/03/22 09:58:55]

Switched to the more straightforward "create a Completer, complete it at the
right time" method.

+              null,
+              (_, x) {
+                checkEntity(x, expected);
+              }).then((_) {
+                for (var v in expected.values) {
+                  Expect.equals('Found', v);
+                }
+              }));
+    }
+  }
+  Future.wait(futures).then((_) {
+    baseDir.deleteSync(recursive: true);
+  });
 }
 
 
 main() {
   testCreateSync();
 }