Change the way Patterns work in scheduled_test/descriptor.

pkg/scheduled_test/test/descriptor_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.
 
 library descriptor_test;
 
 import 'dart:async';
 import 'dart:io';
 
 import '../../../pkg/pathos/lib/path.dart' as path;
@@ skipping 27 matching lines @@
 
       d.file('name.txt', 'contents2').create();
 
       schedule(() {
         expect(new File(path.join(sandbox, 'name.txt')).readAsString(),
             completion(equals('contents2')));
       });
     });
   });
 
-  expectTestsPass('file().create() with a RegExp name fails', () {
-    var errors;
-    test('test 1', () {
-      scheduleSandbox();
-
-      currentSchedule.onException.schedule(() {
-        errors = currentSchedule.errors;
-      });
-
-      d.file(new RegExp(r'name\.txt'), 'contents').create();
-    });
-
-    test('test 2', () {
-      expect(errors, everyElement(new isInstanceOf<ScheduleError>()));
-      expect(errors.map((e) => e.error), equals([
-        r"Pattern /name\.txt/ must be a string."
-      ]), verbose: true);
-    });
-  }, passing: ['test 2']);
-
   expectTestsPass('file().validate() completes successfully if the filesystem '
       'matches the descriptor', () {
     test('test', () {
       scheduleSandbox();
 
       schedule(() {
         return new File(path.join(sandbox, 'name.txt'))
             .writeAsString('contents');
       });
 
@@ skipping 43 matching lines @@
     });
 
     test('test 2', () {
       expect(errors, everyElement(new isInstanceOf<ScheduleError>()));
       expect(errors.length, equals(1));
       expect(errors.first.error,
           matches(r"^File not found: '[^']+[\\/]name\.txt'\.$"));
     });
   }, passing: ['test 2']);
 
-  expectTestsPass('file().validate() with a RegExp completes successfully if '
-      'the filesystem matches the descriptor', () {
-    test('test', () {
-      scheduleSandbox();
-
-      schedule(() {
-        return new File(path.join(sandbox, 'name.txt'))
-            .writeAsString('contents');
-      });
-
-      d.file(new RegExp(r'na..\.txt'), 'contents').validate();
-    });
-  });
-
-  expectTestsPass("file().validate() with a RegExp fails if there's a file "
-      "with the wrong contents", () {
-    var errors;
-    test('test 1', () {
-      scheduleSandbox();
-
-      currentSchedule.onException.schedule(() {
-        errors = currentSchedule.errors;
-      });
-
-      schedule(() {
-        return new File(path.join(sandbox, 'name.txt'))
-            .writeAsString('some\nwrongtents');
-      });
-
-      d.file(new RegExp(r'na..\.txt'), 'some\ncontents\nand stuff').validate();
-    });
-
-    test('test 2', () {
-      expect(errors, everyElement(new isInstanceOf<ScheduleError>()));
-      expect(errors.map((e) => e.error), equals([
-        "File 'name.txt' (matching /na..\\.txt/) should contain:\n"
-        "| some\n"
-        "| contents\n"
-        "| and stuff\n"
-        "but actually contained:\n"
-        "| some\n"
-        "X wrongtents\n"
-        "? and stuff"
-      ]), verbose: true);
-    });
-  }, passing: ['test 2']);
-
-  expectTestsPass("file().validate() with a RegExp fails if there's no "
-      "file", () {
-    var errors;
-    test('test 1', () {
-      scheduleSandbox();
-
-      currentSchedule.onException.schedule(() {
-        errors = currentSchedule.errors;
-      });
-
-      d.file(new RegExp(r'na..\.txt'), 'contents').validate();
-    });
-
-    test('test 2', () {
-      expect(errors, everyElement(new isInstanceOf<ScheduleError>()));
-      expect(errors.length, equals(1));
-      expect(errors.first.error,
-          matches(r"^No entry found in '[^']+' matching /na\.\.\\\.txt/\.$"));
-    });
-  }, passing: ['test 2']);
-
-  expectTestsPass("file().validate() with a RegExp fails if there are multiple "
-      "matching files", () {
-    var errors;
-    test('test 1', () {
-      scheduleSandbox();
-
-      currentSchedule.onException.schedule(() {
-        errors = currentSchedule.errors;
-      });
-
-      schedule(() {
-        return Future.wait([
-          new File(path.join(sandbox, 'name.txt')).writeAsString('contents'),
-          new File(path.join(sandbox, 'nape.txt')).writeAsString('contents'),
-          new File(path.join(sandbox, 'nail.txt')).writeAsString('contents')
-        ]);
-      });
-
-      d.file(new RegExp(r'na..\.txt'), 'contents').validate();
-    });
-
-    test('test 2', () {
-      expect(errors, everyElement(new isInstanceOf<ScheduleError>()));
-      expect(errors.length, equals(1));
-      expect(errors.first.error,
-          matches(
-              r"^Multiple entries found in '[^']+' matching /na\.\.\\\.txt/:\n"
-              r"\* .*[\\/]nail\.txt\n"
-              r"\* .*[\\/]name\.txt\n"
-              r"\* .*[\\/]nape\.txt"));
-    });
-  }, passing: ['test 2']);
-
   expectTestsPass("file().read() returns the contents of the file as a stream",
       () {
     test('test', () {
       expect(byteStreamToString(d.file('name.txt', 'contents').read()),
           completion(equals('contents')));
     });
   });
 
   expectTestsPass("file().load() throws an error", () {
     test('test', () {
       expect(d.file('name.txt', 'contents').load('path').toList(),
           throwsA(equals("Can't load 'path' from within 'name.txt': not a "
                          "directory.")));
     });
   });
 
   expectTestsPass("file().describe() returns the filename", () {
     test('test', () {
       expect(d.file('name.txt', 'contents').describe(), equals('name.txt'));
     });
   });
 
-  expectTestsPass("file().describe() with a RegExp describes the file", () {
-    test('test', () {
-      expect(d.file(new RegExp(r'na..\.txt'), 'contents').describe(),
-          equals(r'file matching /na..\.txt/'));
-    });
-  });
-
   expectTestsPass('binaryFile().create() creates a file', () {
     test('test', () {
       scheduleSandbox();
 
       d.binaryFile('name.bin', [1, 2, 3, 4, 5]).create();
 
       schedule(() {
         expect(new File(path.join(sandbox, 'name.bin')).readAsBytes(),
             completion(equals([1, 2, 3, 4, 5])));
       });
@@ skipping 77 matching lines @@
       d.dir('dir').create();
       d.dir('dir', [d.file('name.txt', 'contents')]).create();
 
       schedule(() {
         expect(new File(path.join(sandbox, 'dir', 'name.txt')).readAsString(),
             completion(equals('contents')));
       });
     });
   });
 
-  expectTestsPass("directory().create() with a RegExp name fails", () {
-    var errors;
-    test('test 1', () {
-      scheduleSandbox();
-
-      currentSchedule.onException.schedule(() {
-        errors = currentSchedule.errors;
-      });
-
-      d.dir(new RegExp('dir')).create();
-    });
-
-    test('test 2', () {
-      expect(errors, everyElement(new isInstanceOf<ScheduleError>()));
-      expect(errors.map((e) => e.error), equals([
-        "Pattern /dir/ must be a string."
-      ]), verbose: true);
-    });
-  }, passing: ['test 2']);
-
   expectTestsPass("directory().validate() completes successfully if the "
       "filesystem matches the descriptor", () {
     test('test', () {
       scheduleSandbox();
 
       schedule(() {
         var dirPath = path.join(sandbox, 'dir');
         var subdirPath = path.join(dirPath, 'subdir');
         return new Directory(subdirPath).create(recursive: true).then((_) {
           return Future.wait([
@@ skipping 143 matching lines @@
       expect(errors, everyElement(new isInstanceOf<ScheduleError>()));
       expect(errors.map((e) => e.error), equals([
         "File 'subfile1.txt' should contain:\n"
         "| subcontents1\n"
         "but actually contained:\n"
         "X wrongtents1"
       ]));
     });
   }, passing: ['test 2']);
 
-  expectTestsPass("directory().validate() with a RegExp completes successfully "
-      "if the filesystem matches the descriptor", () {
-    test('test', () {
-      scheduleSandbox();
-
-      schedule(() {
-        var dirPath = path.join(sandbox, 'dir');
-        var subdirPath = path.join(dirPath, 'subdir');
-        return new Directory(subdirPath).create(recursive: true).then((_) {
-          return Future.wait([
-            new File(path.join(dirPath, 'file1.txt'))
-                .writeAsString('contents1'),
-            new File(path.join(dirPath, 'file2.txt'))
-                .writeAsString('contents2'),
-            new File(path.join(subdirPath, 'subfile1.txt'))
-                .writeAsString('subcontents1'),
-            new File(path.join(subdirPath, 'subfile2.txt'))
-                .writeAsString('subcontents2')
-          ]);
-        });
-      });
-
-      d.dir(new RegExp('d.r'), [
-        d.dir('subdir', [
-          d.file('subfile1.txt', 'subcontents1'),
-          d.file('subfile2.txt', 'subcontents2')
-        ]),
-        d.file('file1.txt', 'contents1'),
-        d.file('file2.txt', 'contents2')
-      ]).validate();
-    });
-  });
-
-  expectTestsPass("directory().validate() with a RegExp fails if there's a dir "
-      "with the wrong contents", () {
-    var errors;
-    test('test 1', () {
-      scheduleSandbox();
-
-      currentSchedule.onException.schedule(() {
-        errors = currentSchedule.errors;
-      });
-
-      schedule(() {
-        var dirPath = path.join(sandbox, 'dir');
-        var subdirPath = path.join(dirPath, 'subdir');
-        return new Directory(subdirPath).create(recursive: true).then((_) {
-          return Future.wait([
-            new File(path.join(dirPath, 'file1.txt'))
-                .writeAsString('contents1'),
-            new File(path.join(subdirPath, 'subfile1.txt'))
-                .writeAsString('subcontents1'),
-            new File(path.join(subdirPath, 'subfile2.txt'))
-                .writeAsString('subcontents2')
-          ]);
-        });
-      });
-
-      d.dir(new RegExp('d.r'), [
-        d.dir('subdir', [
-          d.file('subfile1.txt', 'subcontents1'),
-          d.file('subfile2.txt', 'subcontents2')
-        ]),
-        d.file('file1.txt', 'contents1'),
-        d.file('file2.txt', 'contents2')
-      ]).validate();
-    });
-
-    test('test 2', () {
-      expect(errors, everyElement(new isInstanceOf<ScheduleError>()));
-      expect(errors.length, equals(1));
-      expect(errors.first.error,
-          matches(r"^File not found: '[^']+[\\/]dir[\\/]file2\.txt'\.$"));
-    });
-  }, passing: ['test 2']);
-
-  expectTestsPass("directory().validate() with a RegExp fails if there's no "
-      "dir", () {
-    var errors;
-    test('test 1', () {
-      scheduleSandbox();
-
-      currentSchedule.onException.schedule(() {
-        errors = currentSchedule.errors;
-      });
-
-      d.dir(new RegExp('d.r'), [
-        d.dir('subdir', [
-          d.file('subfile1.txt', 'subcontents1'),
-          d.file('subfile2.txt', 'subcontents2')
-        ]),
-        d.file('file1.txt', 'contents1'),
-        d.file('file2.txt', 'contents2')
-      ]).validate();
-    });
-
-    test('test 2', () {
-      expect(errors, everyElement(new isInstanceOf<ScheduleError>()));
-      expect(errors.length, equals(1));
-      expect(errors.first.error,
-          matches(r"^No entry found in '[^']+' matching /d\.r/\.$"));
-    });
-  }, passing: ['test 2']);
-
-  expectTestsPass("directory().validate() with a RegExp fails if there are "
-      "multiple matching dirs", () {
-    var errors;
-    test('test 1', () {
-      scheduleSandbox();
-
-      currentSchedule.onException.schedule(() {
-        errors = currentSchedule.errors;
-      });
-
-      schedule(() {
-        return Future.wait(['dir', 'dar', 'dor'].map((dir) {
-          var dirPath = path.join(sandbox, dir);
-          var subdirPath = path.join(dirPath, 'subdir');
-          return new Directory(subdirPath).create(recursive: true).then((_) {
-            return Future.wait([
-              new File(path.join(dirPath, 'file1.txt'))
-                  .writeAsString('contents1'),
-              new File(path.join(dirPath, 'file2.txt'))
-                  .writeAsString('contents2'),
-              new File(path.join(subdirPath, 'subfile1.txt'))
-                  .writeAsString('subcontents1'),
-              new File(path.join(subdirPath, 'subfile2.txt'))
-                  .writeAsString('subcontents2')
-            ]);
-          });
-        }));
-      });
-
-      d.dir(new RegExp('d.r'), [
-        d.dir('subdir', [
-          d.file('subfile1.txt', 'subcontents1'),
-          d.file('subfile2.txt', 'subcontents2')
-        ]),
-        d.file('file1.txt', 'contents1'),
-        d.file('file2.txt', 'contents2')
-      ]).validate();
-    });
-
-    test('test 2', () {
-      expect(errors, everyElement(new isInstanceOf<ScheduleError>()));
-      expect(errors.length, equals(1));
-      expect(errors.first.error,
-          matches(
-              r"^Multiple entries found in '[^']+' matching /d\.r/:\n"
-              r"\* .*[\\/]dar\n"
-              r"\* .*[\\/]dir\n"
-              r"\* .*[\\/]dor"));
-    });
-  }, passing: ['test 2']);
-
   expectTestsPass("directory().load() loads a file", () {
     test('test', () {
       var dir = d.dir('dir', [d.file('name.txt', 'contents')]);
       expect(byteStreamToString(dir.load('name.txt')),
           completion(equals('contents')));
     });
   });
 
   expectTestsPass("directory().load() loads a deeply-nested file", () {
     test('test', () {
@@ skipping 49 matching lines @@
           throwsA(equals("Can't load '.' from within 'dir'.")));
 
       expect(dir.load('..').toList(),
           throwsA(equals("Can't load '..' from within 'dir'.")));
 
       expect(dir.load('').toList(),
           throwsA(equals("Can't load '' from within 'dir'.")));
     });
   });
 
-  expectTestsPass("directory().load() fails to load a file with a RegExp name",
-      () {
-    test('test', () {
-      var dir = d.dir('dir', [d.file(new RegExp(r'name\.txt'), 'contents')]);
-
-      expect(dir.load('name.txt').toList(),
-          throwsA(equals(r"Pattern /name\.txt/ must be a string.")));
-    });
-  });
-
   expectTestsPass("directory().load() fails to load a file that doesn't exist",
       () {
     test('test', () {
       var dir = d.dir('dir', [d.file('name.txt', 'contents')]);
 
       expect(dir.load('not-name.txt').toList(),
           throwsA(equals("Couldn't find an entry named 'not-name.txt' within "
               "'dir'.")));
     });
   });
@@ skipping 10 matching lines @@
           throwsA(equals("Found multiple entries named 'name.txt' within "
               "'dir'.")));
     });
   });
 
   expectTestsPass("directory().describe() lists the contents of the directory",
       () {
     test('test', () {
       var dir = d.dir('dir', [
         d.file('file1.txt', 'contents1'),
-        d.file('file2.txt', 'contents2'),
-        d.file(new RegExp(r're\.txt'), 're-contents')
+        d.file('file2.txt', 'contents2')
       ]);
 
       expect(dir.describe(), equals(
           "dir\n"
           "|-- file1.txt\n"
-          "|-- file2.txt\n"
-          "'-- file matching /re\\.txt/"));
+          "'-- file2.txt"));
     });
   });
 
   expectTestsPass("directory().describe() lists the contents of nested "
       "directories", () {
     test('test', () {
       var dir = d.dir('dir', [
         d.file('file1.txt', 'contents1'),
         d.dir('subdir', [
           d.file('subfile1.txt', 'subcontents1'),
@@ skipping 10 matching lines @@
           "|-- file1.txt\n"
           "|-- subdir\n"
           "|   |-- subfile1.txt\n"
           "|   |-- subfile2.txt\n"
           "|   '-- subsubdir\n"
           "|       '-- subsubfile.txt\n"
           "'-- file2.txt"));
     });
   });
 
-  expectTestsPass("directory().describe() with a RegExp describes the "
-      "directory", () {
-    test('test', () {
-      var dir = d.dir(new RegExp(r'd.r'), [
-        d.file('file1.txt', 'contents1'),
-        d.file('file2.txt', 'contents2')
-      ]);
-
-      expect(dir.describe(), equals(
-          "directory matching /d.r/\n"
-          "|-- file1.txt\n"
-          "'-- file2.txt"));
-    });
-  });
-
   expectTestsPass("directory().describe() with no contents returns the "
       "directory name", () {
     test('test', () {
       expect(d.dir('dir').describe(), equals('dir'));
     });
   });
 
   expectTestsPass("async().create() forwards to file().create", () {
     test('test', () {
       scheduleSandbox();
@@ skipping 100 matching lines @@
           matches(r"^Directory not found: '[^']+[\\/]dir'\.$"));
     });
   }, passing: ['test 2']);
 
   expectTestsPass("async().load() fails", () {
     test('test', () {
       scheduleSandbox();
 
       expect(d.async(new Future.immediate(d.file('name.txt')))
               .load('path').toList(),
-          throwsA(equals("Async descriptors don't support load().")));
+          throwsA(equals("AsyncDescriptors don't support load().")));
     });
   });
 
   expectTestsPass("async().read() fails", () {
     test('test', () {
       scheduleSandbox();
 
       expect(d.async(new Future.immediate(d.file('name.txt'))).read().toList(),
-          throwsA(equals("Async descriptors don't support read().")));
+          throwsA(equals("AsyncDescriptors don't support read().")));
     });
   });
 
   expectTestsPass("nothing().create() does nothing", () {
     test('test', () {
       scheduleSandbox();
 
       d.nothing('foo').create();
 
       schedule(() {
         expect(new File(path.join(sandbox, 'foo')).exists(),
             completion(isFalse));
       });
 
       schedule(() {
         expect(new Directory(path.join(sandbox, 'foo')).exists(),
             completion(isFalse));
       });
     });
   });
 
   expectTestsPass("nothing().validate() succeeds if nothing's there", () {
     test('test', () {
       scheduleSandbox();
 
       d.nothing('foo').validate();
     });
   });
 
-  expectTestsPass("nothing().validate() with a RegExp succeeds if nothing's "
-      "there", () {
-    test('test', () {
-      scheduleSandbox();
-
-      d.nothing(new RegExp('f.o')).validate();
-    });
-  });
-
   expectTestsPass("nothing().validate() fails if there's a file", () {
     var errors;
     test('test 1', () {
       scheduleSandbox();
 
       currentSchedule.onException.schedule(() {
         errors = currentSchedule.errors;
       });
 
       d.file('name.txt', 'contents').create();
@@ skipping 24 matching lines @@
 
     test('test 2', () {
       expect(errors, everyElement(new isInstanceOf<ScheduleError>()));
       expect(errors.length, equals(1));
       expect(errors.first.error,
           matches(r"^Expected nothing to exist at '[^']+[\\/]dir', but found a "
               r"directory\.$"));
     });
   }, passing: ['test 2']);
 
-  expectTestsPass("nothing().validate() with a RegExp fails if there are "
-      "multiple entries", () {
+  expectTestsPass("nothing().load() fails", () {
+    test('test', () {
+      scheduleSandbox();
+
+      expect(d.nothing('name.txt').load('path').toList(),
+          throwsA(equals("Nothing descriptors don't support load().")));
+    });
+  });
+
+  expectTestsPass("nothing().read() fails", () {
+    test('test', () {
+      scheduleSandbox();
+
+      expect(d.nothing('name.txt').read().toList(),
+          throwsA(equals("Nothing descriptors don't support read().")));
+    });
+  });
+
+  expectTestsPass("pattern().validate() succeeds if there's a file matching "
+      "the pattern and the child entry", () {
+    test('test', () {
+      scheduleSandbox();
+
+      d.file('foo', 'blap').create();
+
+      d.filePattern(new RegExp(r'f..'), 'blap').validate();
+    });
+  });
+
+  expectTestsPass("pattern().validate() succeeds if there's a dir matching "
+      "the pattern and the child entry", () {
+    test('test', () {
+      scheduleSandbox();
+
+      d.dir('foo', [
+        d.file('bar', 'baz')
+      ]).create();
+
+      d.dirPattern(new RegExp(r'f..'), [
+        d.file('bar', 'baz')
+      ]).validate();
+    });
+  });
+
+  expectTestsPass("pattern().validate() succeeds if there's multiple files "
+      "matching the pattern but only one matching the child entry", () {
+    test('test', () {
+      scheduleSandbox();
+
+      d.file('foo', 'blap').create();
+      d.file('fee', 'blak').create();
+      d.file('faa', 'blut').create();
+
+      d.filePattern(new RegExp(r'f..'), 'blap').validate();
+    });
+  });
+
+  expectTestsPass("pattern().validate() fails if there's no file matching the "
+      "pattern", () {
     var errors;
     test('test 1', () {
       scheduleSandbox();
+
+      currentSchedule.onException.schedule(() {
+        errors = currentSchedule.errors;
+      });
+
+      d.filePattern(new RegExp(r'f..'), 'bar').validate();
+    });
+
+    test('test 2', () {
+      expect(errors, everyElement(new isInstanceOf<ScheduleError>()));
+      expect(errors.length, equals(1));
+      expect(errors.first.error,
+          matches(r"^No entry found in '[^']+' matching /f\.\./\.$"));
+    });
+  }, passing: ['test 2']);
+
+  expectTestsPass("pattern().validate() fails if there's a file matching the "
+      "pattern but not the entry", () {
+    var errors;
+    test('test 1', () {
+      scheduleSandbox();
 
       currentSchedule.onException.schedule(() {
         errors = currentSchedule.errors;
       });
 
-      d.dir('foo').create();
-      d.file('faa', 'contents').create();
-      d.file('not-foo', 'contents').create();
-      d.nothing(new RegExp(r'^f..$')).validate();
+      d.file('foo', 'bap').create();
+      d.filePattern(new RegExp(r'f..'), 'bar').validate();
     });
 
     test('test 2', () {
       expect(errors, everyElement(new isInstanceOf<ScheduleError>()));
       expect(errors.length, equals(1));
       expect(errors.first.error,
-          matches(r"^Expected nothing to exist in '[^']+' matching "
-                  r"/\^f\.\.\$/, but found:\n"
-              r"\* .*[\\/]faa\n"
-              r"\* .*[\\/]foo$"));
+          matches(r"^Caught error\n"
+              r"| File 'foo' should contain:\n"
+              r"| | bar\n"
+              r"| but actually contained:\n"
+              r"| X bap\n"
+              r"while validating\n"
+              r"| foo$"));
     });
   }, passing: ['test 2']);
 
-  expectTestsPass("nothing().load() fails", () {
-    test('test', () {
+  expectTestsPass("pattern().validate() fails if there's a dir matching the "
+      "pattern but not the entry", () {
+    var errors;
+    test('test 1', () {
       scheduleSandbox();
 
-      expect(d.nothing('name.txt').load('path').toList(),
-          throwsA(equals("Nothing descriptors don't support load().")));
+      currentSchedule.onException.schedule(() {
+        errors = currentSchedule.errors;
+      });
+
+      d.dir('foo', [
+        d.file('bar', 'bap')
+      ]).create();
+
+      d.dirPattern(new RegExp(r'f..'), [
+        d.file('bar', 'baz')
+      ]).validate();
     });
-  });
 
-  expectTestsPass("nothing().read() fails", () {
-    test('test', () {
+    test('test 2', () {
+      expect(errors, everyElement(new isInstanceOf<ScheduleError>()));
+      expect(errors.length, equals(1));
+      expect(errors.first.error,
+          matches(r"^Caught error\n"
+              r"| File 'bar' should contain:\n"
+              r"| | baz\n"
+              r"| but actually contained:\n"
+              r"| X bap"
+              r"while validating\n"
+              r"| foo\n"
+              r"| '-- bar$"));
+    });
+  }, passing: ['test 2']);
+
+  expectTestsPass("pattern().validate() fails if there's multiple files "
+      "matching the pattern and the child entry", () {
+    var errors;
+    test('test 1', () {
       scheduleSandbox();
 
-      expect(d.nothing('name.txt').read().toList(),
-          throwsA(equals("Nothing descriptors don't support read().")));
+      currentSchedule.onException.schedule(() {
+        errors = currentSchedule.errors;
+      });
+
+      d.file('foo', 'bar').create();
+      d.file('fee', 'bar').create();
+      d.file('faa', 'bar').create();
+      d.filePattern(new RegExp(r'f..'), 'bar').validate();
     });
-  });
+
+    test('test 2', () {
+      expect(errors, everyElement(new isInstanceOf<ScheduleError>()));
+      expect(errors.length, equals(1));
+      expect(errors.first.error, matches(
+              r"^Multiple valid entries found in '[^']+' matching "
+                  r"\/f\.\./:\n"
+              r"\* faa\n"
+              r"\* fee\n"
+              r"\* foo$"));
+    });
+  }, passing: ['test 2']);
 }
 
 void scheduleSandbox() {
   schedule(() {
     return new Directory('').createTemp().then((dir) {
       sandbox = dir.path;
       d.defaultRoot = sandbox;
     });
   });
 
   currentSchedule.onComplete.schedule(() {
     d.defaultRoot = null;
     if (sandbox == null) return;
     var oldSandbox = sandbox;
     sandbox = null;
     return new Directory(oldSandbox).delete(recursive: true);
   });
 }
 
 Future<List<int>> byteStreamToList(Stream<List<int>> stream) {
   return stream.reduce(<int>[], (buffer, chunk) {
     buffer.addAll(chunk);
     return buffer;
   });
 }
 
 Future<String> byteStreamToString(Stream<List<int>> stream) =>
   byteStreamToList(stream).then((bytes) => new String.fromCharCodes(bytes));