Roll to pickup pool changes

packages/glob/test/match_test.dart

 // 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;
+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))));
+    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*")));
@@ skipping 193 matching lines @@
   });
 
   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));
@@ skipping 12 matching lines @@
     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", 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)));
+    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", 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))));
+      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))));
+      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))));
+      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)));
     });
   });
 }