Index: packages/glob/test/list_test.dart |
diff --git a/packages/glob/test/list_test.dart b/packages/glob/test/list_test.dart |
index d59e273d0240a3d3cbb0755573a9a5480b0435a7..ee9814f15f2ada12c63899c96b1cf0d2709e204a 100644 |
--- a/packages/glob/test/list_test.dart |
+++ b/packages/glob/test/list_test.dart |
@@ -2,27 +2,21 @@ |
// 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. |
+@TestOn('vm') |
import 'dart:async'; |
import 'dart:io'; |
import 'package:glob/glob.dart'; |
import 'package:glob/src/utils.dart'; |
import 'package:path/path.dart' as p; |
-import 'package:scheduled_test/descriptor.dart' as d; |
-import 'package:scheduled_test/scheduled_test.dart'; |
- |
-String sandbox; |
+import 'package:test/test.dart'; |
+import 'package:test_descriptor/test_descriptor.dart' as d; |
void main() { |
- setUp(() { |
- scheduleSandbox(); |
- |
- d.dir("foo", [ |
+ setUp(() async { |
+ await d.dir("foo", [ |
d.file("bar"), |
- d.dir("baz", [ |
- d.file("bang"), |
- d.file("qux") |
- ]) |
+ d.dir("baz", [d.file("bang"), d.file("qux")]) |
]).create(); |
}); |
@@ -31,11 +25,15 @@ void main() { |
expect(new Glob("*", context: p.url).list, throwsStateError); |
}); |
- test("reports exceptions for non-existent directories", () { |
- schedule(() { |
- expect(new Glob("non/existent/**").list().toList(), |
- throwsA(new isInstanceOf<FileSystemException>())); |
- }); |
+ test("reports exceptions for non-existent case-sensitive directories", () { |
+ expect(new Glob("non/existent/**", caseSensitive: true).list().toList(), |
+ throwsA(new isInstanceOf<FileSystemException>())); |
+ }); |
+ |
+ test("reports exceptions for non-existent case-insensitive directories", |
+ () { |
+ expect(new Glob("non/existent/**", caseSensitive: false).list().toList(), |
+ throwsA(new isInstanceOf<FileSystemException>())); |
}); |
}); |
@@ -44,335 +42,304 @@ void main() { |
expect(new Glob("*", context: p.url).listSync, throwsStateError); |
}); |
- test("reports exceptions for non-existent directories", () { |
- schedule(() { |
- expect(new Glob("non/existent/**").listSync, |
- throwsA(new isInstanceOf<FileSystemException>())); |
- }); |
+ test("reports exceptions for non-existent case-sensitive directories", () { |
+ expect(new Glob("non/existent/**", caseSensitive: true).listSync, |
+ throwsA(new isInstanceOf<FileSystemException>())); |
+ }); |
+ |
+ test("reports exceptions for non-existent case-insensitive directories", |
+ () { |
+ expect(new Glob("non/existent/**", caseSensitive: false).listSync, |
+ throwsA(new isInstanceOf<FileSystemException>())); |
}); |
}); |
group("when case-sensitive", () { |
test("lists literals case-sensitively", () { |
- schedule(() { |
- expect(new Glob("foo/BAZ/qux", caseSensitive: true).listSync, |
- throwsA(new isInstanceOf<FileSystemException>())); |
- }); |
+ expect(new Glob("foo/BAZ/qux", caseSensitive: true).listSync, |
+ throwsA(new isInstanceOf<FileSystemException>())); |
}); |
test("lists ranges case-sensitively", () { |
- schedule(() { |
- expect(new Glob("foo/[BX][A-Z]z/qux", caseSensitive: true).listSync, |
- throwsA(new isInstanceOf<FileSystemException>())); |
- }); |
+ expect(new Glob("foo/[BX][A-Z]z/qux", caseSensitive: true).listSync, |
+ throwsA(new isInstanceOf<FileSystemException>())); |
}); |
test("options preserve case-sensitivity", () { |
- schedule(() { |
- expect(new Glob("foo/{BAZ,ZAP}/qux", caseSensitive: true).listSync, |
- throwsA(new isInstanceOf<FileSystemException>())); |
- }); |
+ expect(new Glob("foo/{BAZ,ZAP}/qux", caseSensitive: true).listSync, |
+ throwsA(new isInstanceOf<FileSystemException>())); |
}); |
}); |
- syncAndAsync((list) { |
+ syncAndAsync((ListFn list) { |
group("literals", () { |
- test("lists a single literal", () { |
- expect(list("foo/baz/qux"), |
- completion(equals([p.join("foo", "baz", "qux")]))); |
+ test("lists a single literal", () async { |
+ expect( |
+ await list("foo/baz/qux"), equals([p.join("foo", "baz", "qux")])); |
}); |
- test("lists a non-matching literal", () { |
- expect(list("foo/baz/nothing"), completion(isEmpty)); |
+ test("lists a non-matching literal", () async { |
+ expect(await list("foo/baz/nothing"), isEmpty); |
}); |
}); |
group("star", () { |
- test("lists within filenames but not across directories", () { |
- expect(list("foo/b*"), completion(unorderedEquals([ |
- p.join("foo", "bar"), |
- p.join("foo", "baz") |
- ]))); |
+ test("lists within filenames but not across directories", () async { |
+ expect(await list("foo/b*"), |
+ unorderedEquals([p.join("foo", "bar"), p.join("foo", "baz")])); |
}); |
- test("lists the empy string", () { |
- expect(list("foo/bar*"), completion(equals([p.join("foo", "bar")]))); |
+ test("lists the empy string", () async { |
+ expect(await list("foo/bar*"), equals([p.join("foo", "bar")])); |
}); |
}); |
group("double star", () { |
- test("lists within filenames", () { |
- expect(list("foo/baz/**"), completion(unorderedEquals([ |
- p.join("foo", "baz", "qux"), |
- p.join("foo", "baz", "bang") |
- ]))); |
+ test("lists within filenames", () async { |
+ expect( |
+ await list("foo/baz/**"), |
+ unorderedEquals( |
+ [p.join("foo", "baz", "qux"), p.join("foo", "baz", "bang")])); |
}); |
- test("lists the empty string", () { |
- expect(list("foo/bar**"), completion(equals([p.join("foo", "bar")]))); |
+ test("lists the empty string", () async { |
+ expect(await list("foo/bar**"), equals([p.join("foo", "bar")])); |
}); |
- test("lists recursively", () { |
- expect(list("foo/**"), completion(unorderedEquals([ |
- p.join("foo", "bar"), |
- p.join("foo", "baz"), |
- p.join("foo", "baz", "qux"), |
- p.join("foo", "baz", "bang") |
- ]))); |
+ test("lists recursively", () async { |
+ expect( |
+ await list("foo/**"), |
+ unorderedEquals([ |
+ p.join("foo", "bar"), |
+ p.join("foo", "baz"), |
+ p.join("foo", "baz", "qux"), |
+ p.join("foo", "baz", "bang") |
+ ])); |
}); |
- test("combines with literals", () { |
- expect(list("foo/ba**"), completion(unorderedEquals([ |
- p.join("foo", "bar"), |
- p.join("foo", "baz"), |
- p.join("foo", "baz", "qux"), |
- p.join("foo", "baz", "bang") |
- ]))); |
+ test("combines with literals", () async { |
+ expect( |
+ await list("foo/ba**"), |
+ unorderedEquals([ |
+ p.join("foo", "bar"), |
+ p.join("foo", "baz"), |
+ p.join("foo", "baz", "qux"), |
+ p.join("foo", "baz", "bang") |
+ ])); |
}); |
- test("lists recursively in the middle of a glob", () { |
- d.dir("deep", [ |
+ test("lists recursively in the middle of a glob", () async { |
+ await d.dir("deep", [ |
d.dir("a", [ |
d.dir("b", [ |
- d.dir("c", [ |
- d.file("d"), |
- d.file("long-file") |
- ]), |
+ d.dir("c", [d.file("d"), d.file("long-file")]), |
d.dir("long-dir", [d.file("x")]) |
]) |
]) |
]).create(); |
- expect(list("deep/**/?/?"), completion(unorderedEquals([ |
- p.join("deep", "a", "b", "c"), |
- p.join("deep", "a", "b", "c", "d") |
- ]))); |
+ expect( |
+ await list("deep/**/?/?"), |
+ unorderedEquals([ |
+ p.join("deep", "a", "b", "c"), |
+ p.join("deep", "a", "b", "c", "d") |
+ ])); |
}); |
}); |
group("any char", () { |
- test("matches a character", () { |
- expect(list("foo/ba?"), completion(unorderedEquals([ |
- p.join("foo", "bar"), |
- p.join("foo", "baz") |
- ]))); |
+ test("matches a character", () async { |
+ expect(await list("foo/ba?"), |
+ unorderedEquals([p.join("foo", "bar"), p.join("foo", "baz")])); |
}); |
- test("doesn't match a separator", () { |
- expect(list("foo?bar"), completion(isEmpty)); |
+ test("doesn't match a separator", () async { |
+ expect(await list("foo?bar"), isEmpty); |
}); |
}); |
group("range", () { |
- test("matches a range of characters", () { |
- expect(list("foo/ba[a-z]"), completion(unorderedEquals([ |
- p.join("foo", "bar"), |
- p.join("foo", "baz") |
- ]))); |
+ test("matches a range of characters", () async { |
+ expect(await list("foo/ba[a-z]"), |
+ unorderedEquals([p.join("foo", "bar"), p.join("foo", "baz")])); |
}); |
- test("matches a specific list of characters", () { |
- expect(list("foo/ba[rz]"), completion(unorderedEquals([ |
- p.join("foo", "bar"), |
- p.join("foo", "baz") |
- ]))); |
+ test("matches a specific list of characters", () async { |
+ expect(await list("foo/ba[rz]"), |
+ unorderedEquals([p.join("foo", "bar"), p.join("foo", "baz")])); |
}); |
- test("doesn't match outside its range", () { |
- expect(list("foo/ba[a-x]"), |
- completion(unorderedEquals([p.join("foo", "bar")]))); |
+ test("doesn't match outside its range", () async { |
+ expect( |
+ await list("foo/ba[a-x]"), unorderedEquals([p.join("foo", "bar")])); |
}); |
- test("doesn't match outside its specific list", () { |
- expect(list("foo/ba[rx]"), |
- completion(unorderedEquals([p.join("foo", "bar")]))); |
+ test("doesn't match outside its specific list", () async { |
+ expect( |
+ await list("foo/ba[rx]"), unorderedEquals([p.join("foo", "bar")])); |
}); |
}); |
test("the same file shouldn't be non-recursively listed multiple times", |
- () { |
- d.dir("multi", [ |
+ () async { |
+ await d.dir("multi", [ |
d.dir("start-end", [d.file("file")]) |
]).create(); |
- expect(list("multi/{start-*/f*,*-end/*e}"), |
- completion(equals([p.join("multi", "start-end", "file")]))); |
+ expect(await list("multi/{start-*/f*,*-end/*e}"), |
+ equals([p.join("multi", "start-end", "file")])); |
}); |
- test("the same file shouldn't be recursively listed multiple times", () { |
- d.dir("multi", [ |
+ test("the same file shouldn't be recursively listed multiple times", |
+ () async { |
+ await d.dir("multi", [ |
d.dir("a", [ |
d.dir("b", [ |
d.file("file"), |
- d.dir("c", [ |
- d.file("file") |
- ]) |
+ d.dir("c", [d.file("file")]) |
]), |
d.dir("x", [ |
- d.dir("y", [ |
- d.file("file") |
- ]) |
+ d.dir("y", [d.file("file")]) |
]) |
]) |
]).create(); |
- expect(list("multi/{*/*/*/file,a/**/file}"), completion(unorderedEquals([ |
- p.join("multi", "a", "b", "file"), |
- p.join("multi", "a", "b", "c", "file"), |
- p.join("multi", "a", "x", "y", "file") |
- ]))); |
+ expect( |
+ await list("multi/{*/*/*/file,a/**/file}"), |
+ unorderedEquals([ |
+ p.join("multi", "a", "b", "file"), |
+ p.join("multi", "a", "b", "c", "file"), |
+ p.join("multi", "a", "x", "y", "file") |
+ ])); |
}); |
group("with symlinks", () { |
- setUp(() { |
- schedule(() { |
- return new Link(p.join(sandbox, "dir", "link")) |
- .create(p.join(sandbox, "foo", "baz"), recursive: true); |
- }, "symlink foo/baz to dir/link"); |
+ setUp(() async { |
+ await new Link(p.join(d.sandbox, "dir", "link")) |
+ .create(p.join(d.sandbox, "foo", "baz"), recursive: true); |
}); |
- test("follows symlinks by default", () { |
- expect(list("dir/**"), completion(unorderedEquals([ |
- p.join("dir", "link"), |
- p.join("dir", "link", "bang"), |
- p.join("dir", "link", "qux") |
- ]))); |
+ test("follows symlinks by default", () async { |
+ expect( |
+ await list("dir/**"), |
+ unorderedEquals([ |
+ p.join("dir", "link"), |
+ p.join("dir", "link", "bang"), |
+ p.join("dir", "link", "qux") |
+ ])); |
}); |
- test("doesn't follow symlinks with followLinks: false", () { |
- expect(list("dir/**", followLinks: false), |
- completion(equals([p.join("dir", "link")]))); |
+ test("doesn't follow symlinks with followLinks: false", () async { |
+ expect(await list("dir/**", followLinks: false), |
+ equals([p.join("dir", "link")])); |
}); |
- test("shouldn't crash on broken symlinks", () { |
- schedule(() { |
- return new Directory(p.join(sandbox, "foo")).delete(recursive: true); |
- }); |
+ test("shouldn't crash on broken symlinks", () async { |
+ await new Directory(p.join(d.sandbox, "foo")).delete(recursive: true); |
- expect(list("dir/**"), completion(equals([p.join("dir", "link")]))); |
+ expect(await list("dir/**"), equals([p.join("dir", "link")])); |
}); |
}); |
- test("always lists recursively with recursive: true", () { |
- expect(list("foo", recursive: true), completion(unorderedEquals([ |
- "foo", |
- p.join("foo", "bar"), |
- p.join("foo", "baz"), |
- p.join("foo", "baz", "qux"), |
- p.join("foo", "baz", "bang") |
- ]))); |
+ test("always lists recursively with recursive: true", () async { |
+ expect( |
+ await list("foo", recursive: true), |
+ unorderedEquals([ |
+ "foo", |
+ p.join("foo", "bar"), |
+ p.join("foo", "baz"), |
+ p.join("foo", "baz", "qux"), |
+ p.join("foo", "baz", "bang") |
+ ])); |
}); |
- test("lists an absolute glob", () { |
- expect(schedule(() { |
- var pattern = separatorToForwardSlash( |
- p.absolute(p.join(sandbox, 'foo/baz/**'))); |
+ test("lists an absolute glob", () async { |
+ var pattern = |
+ separatorToForwardSlash(p.absolute(p.join(d.sandbox, 'foo/baz/**'))); |
- return list(pattern); |
- }), completion(unorderedEquals([ |
- p.join("foo", "baz", "bang"), |
- p.join("foo", "baz", "qux") |
- ]))); |
+ var result = await list(pattern); |
+ |
+ expect( |
+ result, |
+ unorderedEquals( |
+ [p.join("foo", "baz", "bang"), p.join("foo", "baz", "qux")])); |
}); |
// Regression test for #4. |
- test("lists an absolute case-insensitive glob", () { |
- expect(schedule(() { |
- var pattern = separatorToForwardSlash( |
- p.absolute(p.join(sandbox, 'foo/Baz/**'))); |
- |
- return list(pattern, caseSensitive: false); |
- }), completion(unorderedEquals([ |
- p.join("foo", "baz", "bang"), |
- p.join("foo", "baz", "qux") |
- ]))); |
+ test("lists an absolute case-insensitive glob", () async { |
+ var pattern = |
+ separatorToForwardSlash(p.absolute(p.join(d.sandbox, 'foo/Baz/**'))); |
+ |
+ expect( |
+ await list(pattern, caseSensitive: false), |
+ unorderedEquals( |
+ [p.join("foo", "baz", "bang"), p.join("foo", "baz", "qux")])); |
}); |
- test("lists a subdirectory that sometimes exists", () { |
- d.dir("top", [ |
+ test("lists a subdirectory that sometimes exists", () async { |
+ await d.dir("top", [ |
d.dir("dir1", [ |
d.dir("subdir", [d.file("file")]) |
]), |
d.dir("dir2", []) |
]).create(); |
- expect(list("top/*/subdir/**"), |
- completion(equals([p.join("top", "dir1", "subdir", "file")]))); |
+ expect(await list("top/*/subdir/**"), |
+ equals([p.join("top", "dir1", "subdir", "file")])); |
}); |
group("when case-insensitive", () { |
- test("lists literals case-insensitively", () { |
- expect(list("foo/baz/qux", caseSensitive: false), |
- completion(equals([p.join("foo", "baz", "qux")]))); |
- expect(list("foo/BAZ/qux", caseSensitive: false), |
- completion(equals([p.join("foo", "baz", "qux")]))); |
+ test("lists literals case-insensitively", () async { |
+ expect(await list("foo/baz/qux", caseSensitive: false), |
+ equals([p.join("foo", "baz", "qux")])); |
+ expect(await list("foo/BAZ/qux", caseSensitive: false), |
+ equals([p.join("foo", "baz", "qux")])); |
}); |
- test("lists ranges case-insensitively", () { |
- expect(list("foo/[bx][a-z]z/qux", caseSensitive: false), |
- completion(equals([p.join("foo", "baz", "qux")]))); |
- expect(list("foo/[BX][A-Z]z/qux", caseSensitive: false), |
- completion(equals([p.join("foo", "baz", "qux")]))); |
+ test("lists ranges case-insensitively", () async { |
+ expect(await list("foo/[bx][a-z]z/qux", caseSensitive: false), |
+ equals([p.join("foo", "baz", "qux")])); |
+ expect(await list("foo/[BX][A-Z]z/qux", caseSensitive: false), |
+ equals([p.join("foo", "baz", "qux")])); |
}); |
- test("options preserve case-insensitivity", () { |
- expect(list("foo/{bar,baz}/qux", caseSensitive: false), |
- completion(equals([p.join("foo", "baz", "qux")]))); |
- expect(list("foo/{BAR,BAZ}/qux", caseSensitive: false), |
- completion(equals([p.join("foo", "baz", "qux")]))); |
+ test("options preserve case-insensitivity", () async { |
+ expect(await list("foo/{bar,baz}/qux", caseSensitive: false), |
+ equals([p.join("foo", "baz", "qux")])); |
+ expect(await list("foo/{BAR,BAZ}/qux", caseSensitive: false), |
+ equals([p.join("foo", "baz", "qux")])); |
}); |
}); |
}); |
} |
-typedef Future<List<String>> ListFn(String glob, |
+typedef FutureOr<List<String>> ListFn(String glob, |
{bool recursive, bool followLinks, bool caseSensitive}); |
/// Runs [callback] in two groups with two values of [listFn]: one that uses |
/// [Glob.list], one that uses [Glob.listSync]. |
-void syncAndAsync(callback(ListFn listFn)) { |
+void syncAndAsync(FutureOr callback(ListFn listFn)) { |
group("async", () { |
callback((pattern, {recursive: false, followLinks: true, caseSensitive}) { |
- return schedule(() { |
- var glob = new Glob(pattern, |
- recursive: recursive, caseSensitive: caseSensitive); |
- |
- return glob |
- .list(root: sandbox, followLinks: followLinks) |
- .map((entity) => p.relative(entity.path, from: sandbox)) |
- .toList(); |
- }, 'listing $pattern'); |
+ var glob = |
+ new Glob(pattern, recursive: recursive, caseSensitive: caseSensitive); |
+ |
+ return glob |
+ .list(root: d.sandbox, followLinks: followLinks) |
+ .map((entity) => p.relative(entity.path, from: d.sandbox)) |
+ .toList(); |
}); |
}); |
group("sync", () { |
callback((pattern, {recursive: false, followLinks: true, caseSensitive}) { |
- return schedule(() { |
- var glob = new Glob(pattern, |
- recursive: recursive, caseSensitive: caseSensitive); |
- |
- return glob |
- .listSync(root: sandbox, followLinks: followLinks) |
- .map((entity) => p.relative(entity.path, from: sandbox)) |
- .toList(); |
- }, 'listing $pattern'); |
- }); |
- }); |
-} |
+ var glob = |
+ new Glob(pattern, recursive: recursive, caseSensitive: caseSensitive); |
-void scheduleSandbox() { |
- schedule(() { |
- return Directory.systemTemp.createTemp('glob_').then((dir) { |
- sandbox = dir.path; |
- d.defaultRoot = sandbox; |
+ return glob |
+ .listSync(root: d.sandbox, followLinks: followLinks) |
+ .map((entity) => p.relative(entity.path, from: d.sandbox)) |
+ .toList(); |
}); |
- }, 'creating sandbox'); |
- |
- currentSchedule.onComplete.schedule(() { |
- d.defaultRoot = null; |
- if (sandbox == null) return null; |
- var oldSandbox = sandbox; |
- sandbox = null; |
- return new Directory(oldSandbox).delete(recursive: true); |
}); |
} |