| // Copyright (c) 2014, 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 'package:glob/glob.dart'; |
| import 'package:glob/src/utils.dart'; |
| import 'package:path/path.dart' as p; |
| import 'package:test/test.dart'; |
| |
| const RAW_ASCII_WITHOUT_SLASH = "\t\n\r !\"#\$%&'()*+`-.0123456789:;<=>?@ABCDEF" |
| "GHIJKLMNOPQRSTUVWXYZ[]^_`abcdefghijklmnopqrstuvwxyz{|}~"; |
| |
| // URL-encode the path for a URL context. |
| final asciiWithoutSlash = p.style == p.Style.url |
| ? Uri.encodeFull(RAW_ASCII_WITHOUT_SLASH) |
| : RAW_ASCII_WITHOUT_SLASH; |
| |
| void main() { |
| test("literals match exactly", () { |
| expect("foo", contains(new Glob("foo"))); |
| expect("foo/bar", contains(new Glob("foo/bar"))); |
| expect("foo*", contains(new Glob(r"foo\*"))); |
| }); |
| |
| test("backslashes match nothing on Windows", () { |
| expect( |
| r"foo\bar", isNot(contains(new Glob(r"foo\\bar", context: p.windows)))); |
| }); |
| |
| group("star", () { |
| test("matches non-separator characters", () { |
| var glob = new Glob("*"); |
| expect(asciiWithoutSlash, contains(glob)); |
| }); |
| |
| test("matches the empty string", () { |
| expect("foo", contains(new Glob("foo*"))); |
| expect("", contains(new Glob("*"))); |
| }); |
| |
| test("doesn't match separators", () { |
| var glob = new Glob("*"); |
| expect("foo/bar", isNot(contains(glob))); |
| }); |
| }); |
| |
| group("double star", () { |
| test("matches non-separator characters", () { |
| var glob = new Glob("**"); |
| expect(asciiWithoutSlash, contains(glob)); |
| }); |
| |
| test("matches the empty string", () { |
| var glob = new Glob("foo**"); |
| expect("foo", contains(glob)); |
| }); |
| |
| test("matches any level of nesting", () { |
| var glob = new Glob("**"); |
| expect("a", contains(glob)); |
| expect("a/b/c/d/e/f", contains(glob)); |
| }); |
| |
| test("doesn't match unresolved dot dots", () { |
| expect("../foo/bar", isNot(contains(new Glob("**")))); |
| }); |
| |
| test("matches entities containing dot dots", () { |
| expect("..foo/bar", contains(new Glob("**"))); |
| expect("foo../bar", contains(new Glob("**"))); |
| expect("foo/..bar", contains(new Glob("**"))); |
| expect("foo/bar..", contains(new Glob("**"))); |
| }); |
| }); |
| |
| group("any char", () { |
| test("matches any non-separator character", () { |
| var glob = new Glob("foo?"); |
| for (var char in RAW_ASCII_WITHOUT_SLASH.split('')) { |
| if (p.style == p.Style.url) char = Uri.encodeFull(char); |
| expect("foo$char", contains(glob)); |
| } |
| }); |
| |
| test("doesn't match a separator", () { |
| expect("foo/bar", isNot(contains(new Glob("foo?bar")))); |
| }); |
| }); |
| |
| group("range", () { |
| test("can match individual characters", () { |
| var glob = new Glob("foo[a<.*]"); |
| expect("fooa", contains(glob)); |
| expect("foo<", contains(glob)); |
| expect("foo.", contains(glob)); |
| expect("foo*", contains(glob)); |
| expect("foob", isNot(contains(glob))); |
| expect("foo>", isNot(contains(glob))); |
| }); |
| |
| test("can match a range of characters", () { |
| var glob = new Glob("foo[a-z]"); |
| expect("fooa", contains(glob)); |
| expect("foon", contains(glob)); |
| expect("fooz", contains(glob)); |
| expect("foo`", isNot(contains(glob))); |
| expect("foo{", isNot(contains(glob))); |
| }); |
| |
| test("can match multiple ranges of characters", () { |
| var glob = new Glob("foo[a-zA-Z]"); |
| expect("fooa", contains(glob)); |
| expect("foon", contains(glob)); |
| expect("fooz", contains(glob)); |
| expect("fooA", contains(glob)); |
| expect("fooN", contains(glob)); |
| expect("fooZ", contains(glob)); |
| expect("foo?", isNot(contains(glob))); |
| expect("foo{", isNot(contains(glob))); |
| }); |
| |
| test("can match individual characters and ranges of characters", () { |
| var glob = new Glob("foo[a-z_A-Z]"); |
| expect("fooa", contains(glob)); |
| expect("foon", contains(glob)); |
| expect("fooz", contains(glob)); |
| expect("fooA", contains(glob)); |
| expect("fooN", contains(glob)); |
| expect("fooZ", contains(glob)); |
| expect("foo_", contains(glob)); |
| expect("foo?", isNot(contains(glob))); |
| expect("foo{", isNot(contains(glob))); |
| }); |
| |
| test("can be negated", () { |
| var glob = new Glob("foo[^a<.*]"); |
| expect("fooa", isNot(contains(glob))); |
| expect("foo<", isNot(contains(glob))); |
| expect("foo.", isNot(contains(glob))); |
| expect("foo*", isNot(contains(glob))); |
| expect("foob", contains(glob)); |
| expect("foo>", contains(glob)); |
| }); |
| |
| test("never matches separators", () { |
| // "\t-~" contains "/". |
| expect("foo/bar", isNot(contains(new Glob("foo[\t-~]bar")))); |
| expect("foo/bar", isNot(contains(new Glob("foo[^a]bar")))); |
| }); |
| |
| test("allows dangling -", () { |
| expect("-", contains(new Glob(r"[-]"))); |
| |
| var glob = new Glob(r"[a-]"); |
| expect("-", contains(glob)); |
| expect("a", contains(glob)); |
| |
| glob = new Glob(r"[-b]"); |
| expect("-", contains(glob)); |
| expect("b", contains(glob)); |
| }); |
| |
| test("allows multiple -s", () { |
| expect("-", contains(new Glob(r"[--]"))); |
| expect("-", contains(new Glob(r"[---]"))); |
| |
| var glob = new Glob(r"[--a]"); |
| expect("-", contains(glob)); |
| expect("a", contains(glob)); |
| }); |
| |
| test("allows negated /", () { |
| expect("foo-bar", contains(new Glob("foo[^/]bar"))); |
| }); |
| |
| test("doesn't choke on RegExp-active characters", () { |
| var glob = new Glob(r"foo[\]].*"); |
| expect("foobar", isNot(contains(glob))); |
| expect("foo].*", contains(glob)); |
| }); |
| }); |
| |
| group("options", () { |
| test("match if any of the options match", () { |
| var glob = new Glob("foo/{bar,baz,bang}"); |
| expect("foo/bar", contains(glob)); |
| expect("foo/baz", contains(glob)); |
| expect("foo/bang", contains(glob)); |
| expect("foo/qux", isNot(contains(glob))); |
| }); |
| |
| test("can contain nested operators", () { |
| var glob = new Glob("foo/{ba?,*az,ban{g,f}}"); |
| expect("foo/bar", contains(glob)); |
| expect("foo/baz", contains(glob)); |
| expect("foo/bang", contains(glob)); |
| expect("foo/qux", isNot(contains(glob))); |
| }); |
| |
| test("can conditionally match separators", () { |
| var glob = new Glob("foo/{bar,baz/bang}"); |
| expect("foo/bar", contains(glob)); |
| expect("foo/baz/bang", contains(glob)); |
| expect("foo/baz", isNot(contains(glob))); |
| expect("foo/bar/bang", isNot(contains(glob))); |
| }); |
| }); |
| |
| group("normalization", () { |
| test("extra slashes are ignored", () { |
| expect("foo//bar", contains(new Glob("foo/bar"))); |
| expect("foo/", contains(new Glob("*"))); |
| }); |
| |
| test("dot directories are ignored", () { |
| expect("foo/./bar", contains(new Glob("foo/bar"))); |
| expect("foo/.", contains(new Glob("foo"))); |
| }); |
| |
| test("dot dot directories are resolved", () { |
| expect("foo/../bar", contains(new Glob("bar"))); |
| expect("../foo/bar", contains(new Glob("../foo/bar"))); |
| expect("foo/../../bar", contains(new Glob("../bar"))); |
| }); |
| |
| test("Windows separators are converted in a Windows context", () { |
| expect(r"foo\bar", contains(new Glob("foo/bar", context: p.windows))); |
| expect(r"foo\bar/baz", |
| contains(new Glob("foo/bar/baz", context: p.windows))); |
| }); |
| }); |
| |
| test("an absolute path can be matched by a relative glob", () { |
| var path = p.absolute('foo/bar'); |
| expect(path, contains(new Glob("foo/bar"))); |
| }); |
| |
| test("a relative path can be matched by an absolute glob", () { |
| var pattern = separatorToForwardSlash(p.absolute('foo/bar')); |
| expect('foo/bar', contains(new Glob(pattern))); |
| }, testOn: 'vm'); |
| |
| group("with recursive: true", () { |
| var glob = new Glob("foo/bar", recursive: true); |
| |
| test("still matches basic files", () { |
| expect("foo/bar", contains(glob)); |
| }); |
| |
| test("matches subfiles", () { |
| expect("foo/bar/baz", contains(glob)); |
| expect("foo/bar/baz/bang", contains(glob)); |
| }); |
| |
| test("doesn't match suffixes", () { |
| expect("foo/barbaz", isNot(contains(glob))); |
| expect("foo/barbaz/bang", isNot(contains(glob))); |
| }); |
| }); |
| |
| test("absolute POSIX paths", () { |
| expect("/foo/bar", contains(new Glob("/foo/bar", context: p.posix))); |
| expect("/foo/bar", isNot(contains(new Glob("**", context: p.posix)))); |
| expect("/foo/bar", contains(new Glob("/**", context: p.posix))); |
| }); |
| |
| test("absolute Windows paths", () { |
| expect(r"C:\foo\bar", contains(new Glob("C:/foo/bar", context: p.windows))); |
| expect(r"C:\foo\bar", isNot(contains(new Glob("**", context: p.windows)))); |
| expect(r"C:\foo\bar", contains(new Glob("C:/**", context: p.windows))); |
| |
| expect(r"\\foo\bar\baz", |
| contains(new Glob("//foo/bar/baz", context: p.windows))); |
| expect( |
| r"\\foo\bar\baz", isNot(contains(new Glob("**", context: p.windows)))); |
| expect(r"\\foo\bar\baz", contains(new Glob("//**", context: p.windows))); |
| expect( |
| r"\\foo\bar\baz", contains(new Glob("//foo/**", context: p.windows))); |
| }); |
| |
| test("absolute URL paths", () { |
| expect(r"http://foo.com/bar", |
| contains(new Glob("http://foo.com/bar", context: p.url))); |
| expect( |
| r"http://foo.com/bar", isNot(contains(new Glob("**", context: p.url)))); |
| expect( |
| r"http://foo.com/bar", contains(new Glob("http://**", context: p.url))); |
| expect(r"http://foo.com/bar", |
| contains(new Glob("http://foo.com/**", context: p.url))); |
| |
| expect("/foo/bar", contains(new Glob("/foo/bar", context: p.url))); |
| expect("/foo/bar", isNot(contains(new Glob("**", context: p.url)))); |
| expect("/foo/bar", contains(new Glob("/**", context: p.url))); |
| }); |
| |
| group("when case-sensitive", () { |
| test("literals match case-sensitively", () { |
| expect("foo", contains(new Glob("foo", caseSensitive: true))); |
| expect("FOO", isNot(contains(new Glob("foo", caseSensitive: true)))); |
| expect("foo", isNot(contains(new Glob("FOO", caseSensitive: true)))); |
| }); |
| |
| test("ranges match case-sensitively", () { |
| expect("foo", contains(new Glob("[fx][a-z]o", caseSensitive: true))); |
| expect( |
| "FOO", isNot(contains(new Glob("[fx][a-z]o", caseSensitive: true)))); |
| expect( |
| "foo", isNot(contains(new Glob("[FX][A-Z]O", caseSensitive: true)))); |
| }); |
| |
| test("sequences preserve case-sensitivity", () { |
| expect("foo/bar", contains(new Glob("foo/bar", caseSensitive: true))); |
| expect( |
| "FOO/BAR", isNot(contains(new Glob("foo/bar", caseSensitive: true)))); |
| expect( |
| "foo/bar", isNot(contains(new Glob("FOO/BAR", caseSensitive: true)))); |
| }); |
| |
| test("options preserve case-sensitivity", () { |
| expect("foo", contains(new Glob("{foo,bar}", caseSensitive: true))); |
| expect( |
| "FOO", isNot(contains(new Glob("{foo,bar}", caseSensitive: true)))); |
| expect( |
| "foo", isNot(contains(new Glob("{FOO,BAR}", caseSensitive: true)))); |
| }); |
| }); |
| |
| group("when case-insensitive", () { |
| test("literals match case-insensitively", () { |
| expect("foo", contains(new Glob("foo", caseSensitive: false))); |
| expect("FOO", contains(new Glob("foo", caseSensitive: false))); |
| expect("foo", contains(new Glob("FOO", caseSensitive: false))); |
| }); |
| |
| test("ranges match case-insensitively", () { |
| expect("foo", contains(new Glob("[fx][a-z]o", caseSensitive: false))); |
| expect("FOO", contains(new Glob("[fx][a-z]o", caseSensitive: false))); |
| expect("foo", contains(new Glob("[FX][A-Z]O", caseSensitive: false))); |
| }); |
| |
| test("sequences preserve case-insensitivity", () { |
| expect("foo/bar", contains(new Glob("foo/bar", caseSensitive: false))); |
| expect("FOO/BAR", contains(new Glob("foo/bar", caseSensitive: false))); |
| expect("foo/bar", contains(new Glob("FOO/BAR", caseSensitive: false))); |
| }); |
| |
| test("options preserve case-insensitivity", () { |
| expect("foo", contains(new Glob("{foo,bar}", caseSensitive: false))); |
| expect("FOO", contains(new Glob("{foo,bar}", caseSensitive: false))); |
| expect("foo", contains(new Glob("{FOO,BAR}", caseSensitive: false))); |
| }); |
| }); |
| } |