diff --git a/.travis.yml b/.travis.yml
new file mode 100644
index 0000000..45a6c6e
--- /dev/null
+++ b/.travis.yml
@@ -0,0 +1,27 @@
+language: dart
+
+# Speed up builds by using containerization.
+sudo: false
+
+dart:
+  - dev
+  - stable
+
+# See https://docs.travis-ci.com/user/languages/dart/ for details.
+dart_task:
+  - test: --platform vm,dartium,firefox
+    install_dartium: true
+  - dartanalyzer
+
+# Only building master means that we don't run two builds for each pull request.
+branches:
+  only: [master]
+
+matrix:
+  include:
+    - dart: stable
+      dart_task: dartfmt
+
+cache:
+  directories:
+    - $HOME/.pub-cache
diff --git a/lib/glob.dart b/lib/glob.dart
index ca83969..a7d6b4c 100644
--- a/lib/glob.dart
+++ b/lib/glob.dart
@@ -58,6 +58,7 @@
     }
     return _contextIsAbsoluteCache;
   }
+
   bool _contextIsAbsoluteCache;
 
   /// Whether [pattern] could match absolute paths.
@@ -67,6 +68,7 @@
     }
     return _patternCanMatchAbsoluteCache;
   }
+
   bool _patternCanMatchAbsoluteCache;
 
   /// Whether [pattern] could match relative paths.
@@ -76,6 +78,7 @@
     }
     return _patternCanMatchRelativeCache;
   }
+
   bool _patternCanMatchRelativeCache;
 
   /// Returns [contents] with characters that are meaningful in globs
@@ -95,8 +98,8 @@
   /// case matches that of the characters in the glob. Otherwise, it matches
   /// regardless of case. This defaults to `false` when [context] is Windows and
   /// `true` otherwise.
-  factory Glob(String pattern, {p.Context context, bool recursive: false,
-      bool caseSensitive}) {
+  factory Glob(String pattern,
+      {p.Context context, bool recursive: false, bool caseSensitive}) {
     context ??= p.context;
     caseSensitive ??= context.style == p.Style.windows ? false : true;
     if (recursive) pattern += "{,/**}";
diff --git a/lib/src/ast.dart b/lib/src/ast.dart
index 5e24e2b..c703711 100644
--- a/lib/src/ast.dart
+++ b/lib/src/ast.dart
@@ -38,9 +38,9 @@
   ///
   /// For example, given the glob `{foo,bar}/{click/clack}`, this would return
   /// `{foo/click,foo/clack,bar/click,bar/clack}`.
-  OptionsNode flattenOptions() => new OptionsNode(
-      [new SequenceNode([this], caseSensitive: caseSensitive)],
-      caseSensitive: caseSensitive);
+  OptionsNode flattenOptions() => new OptionsNode([
+        new SequenceNode([this], caseSensitive: caseSensitive)
+      ], caseSensitive: caseSensitive);
 
   /// Returns whether this glob matches [string].
   bool matches(String string) {
@@ -71,8 +71,8 @@
       return new OptionsNode([this], caseSensitive: caseSensitive);
     }
 
-    var sequences = nodes.first.flattenOptions().options
-        .map((sequence) => sequence.nodes);
+    var sequences =
+        nodes.first.flattenOptions().options.map((sequence) => sequence.nodes);
     for (var node in nodes.skip(1)) {
       // Concatenate all sequences in the next options node ([nextSequences])
       // onto all previous sequences ([sequences]).
@@ -86,18 +86,22 @@
 
     return new OptionsNode(sequences.map((sequence) {
       // Combine any adjacent LiteralNodes in [sequence].
-      return new SequenceNode(sequence.fold/*<List<AstNode>>*/([], (combined, node) {
-        if (combined.isEmpty || combined.last is! LiteralNode ||
-            node is! LiteralNode) {
-          return combined..add(node);
-        }
+      return new SequenceNode(
+          sequence.fold/*<List<AstNode>>*/([], (combined, node) {
+            if (combined.isEmpty ||
+                combined.last is! LiteralNode ||
+                node is! LiteralNode) {
+              return combined..add(node);
+            }
 
-        combined[combined.length - 1] = new LiteralNode(
-            // TODO(nweiz): Avoid casting when sdk#25565 is fixed.
-            (combined.last as LiteralNode).text + (node as LiteralNode).text,
-            caseSensitive: caseSensitive);
-        return combined;
-      }), caseSensitive: caseSensitive);
+            combined[combined.length - 1] = new LiteralNode(
+                // TODO(nweiz): Avoid casting when sdk#25565 is fixed.
+                (combined.last as LiteralNode).text +
+                    (node as LiteralNode).text,
+                caseSensitive: caseSensitive);
+            return combined;
+          }),
+          caseSensitive: caseSensitive);
     }), caseSensitive: caseSensitive);
   }
 
@@ -185,7 +189,8 @@
 
   String _toRegExp() => nodes.map((node) => node._toRegExp()).join();
 
-  bool operator==(Object other) => other is SequenceNode &&
+  bool operator ==(Object other) =>
+      other is SequenceNode &&
       const IterableEquality().equals(nodes, other.nodes);
 
   int get hashCode => const IterableEquality().hash(nodes);
@@ -199,7 +204,7 @@
 
   String _toRegExp() => '[^/]*';
 
-  bool operator==(Object other) => other is StarNode;
+  bool operator ==(Object other) => other is StarNode;
 
   int get hashCode => 0;
 
@@ -241,7 +246,7 @@
     return buffer.toString();
   }
 
-  bool operator==(Object other) => other is DoubleStarNode;
+  bool operator ==(Object other) => other is DoubleStarNode;
 
   int get hashCode => 1;
 
@@ -254,7 +259,7 @@
 
   String _toRegExp() => '[^/]';
 
-  bool operator==(Object other) => other is AnyCharNode;
+  bool operator ==(Object other) => other is AnyCharNode;
 
   int get hashCode => 2;
 
@@ -319,7 +324,7 @@
     return buffer.toString();
   }
 
-  bool operator==(Object other) {
+  bool operator ==(Object other) {
     if (other is! RangeNode) return false;
     if ((other as RangeNode).negated != negated) return false;
     return const SetEquality().equals(ranges, (other as RangeNode).ranges);
@@ -359,7 +364,8 @@
   String _toRegExp() =>
       '(?:${options.map((option) => option._toRegExp()).join("|")})';
 
-  bool operator==(Object other) => other is OptionsNode &&
+  bool operator ==(Object other) =>
+      other is OptionsNode &&
       const UnorderedIterableEquality().equals(options, other.options);
 
   int get hashCode => const UnorderedIterableEquality().hash(options);
@@ -378,8 +384,8 @@
   final p.Context _context;
 
   bool get canMatchAbsolute {
-    var nativeText = _context.style == p.Style.windows ?
-        text.replaceAll('/', '\\') : text;
+    var nativeText =
+        _context.style == p.Style.windows ? text.replaceAll('/', '\\') : text;
     return _context.isAbsolute(nativeText);
   }
 
@@ -391,7 +397,7 @@
 
   String _toRegExp() => regExpQuote(text);
 
-  bool operator==(Object other) => other is LiteralNode && other.text == text;
+  bool operator ==(Object other) => other is LiteralNode && other.text == text;
 
   int get hashCode => text.hashCode;
 
diff --git a/lib/src/list_tree.dart b/lib/src/list_tree.dart
index c886ec7..deffdc9 100644
--- a/lib/src/list_tree.dart
+++ b/lib/src/list_tree.dart
@@ -143,8 +143,8 @@
           parent = parent.children[component];
         }
       } else if (recursive) {
-        _trees[root] = new _ListTreeNode.recursive(
-            _join(components.sublist(i)));
+        _trees[root] =
+            new _ListTreeNode.recursive(_join(components.sublist(i)));
         return;
       } else if (complete) {
         _trees[root] = new _ListTreeNode()..addOption(component);
@@ -300,8 +300,8 @@
   /// Adds [validator] to this node's existing validator.
   void addOption(SequenceNode validator) {
     if (_validator == null) {
-      _validator = new OptionsNode([validator],
-          caseSensitive: validator.caseSensitive);
+      _validator =
+          new OptionsNode([validator], caseSensitive: validator.caseSensitive);
     } else {
       _validator.options.add(validator);
     }
@@ -313,7 +313,8 @@
   /// [ListTree.list].
   Stream<FileSystemEntity> list(String dir, {bool followLinks: true}) {
     if (isRecursive) {
-      return new Directory(dir).list(recursive: true, followLinks: followLinks)
+      return new Directory(dir)
+          .list(recursive: true, followLinks: followLinks)
           .where((entity) => _matches(p.relative(entity.path, from: dir)));
     }
 
@@ -331,8 +332,8 @@
     }
 
     return StreamCompleter.fromFuture(() async {
-      var entities = await new Directory(dir)
-          .list(followLinks: followLinks).toList();
+      var entities =
+          await new Directory(dir).list(followLinks: followLinks).toList();
       await _validateIntermediateChildrenAsync(dir, entities);
 
       var resultGroup = new StreamGroup<FileSystemEntity>();
@@ -354,7 +355,7 @@
             // succeed if "foo/bar/qux/baz" doesn't exist.
             return error is FileSystemException &&
                 (error.osError.errorCode == _ENOENT ||
-                error.osError.errorCode == _ENOENT_WIN);
+                    error.osError.errorCode == _ENOENT_WIN);
           });
           resultGroup.add(stream);
         });
@@ -371,15 +372,15 @@
   ///
   /// This ensures that listing "foo/bar/*" fails on case-sensitive systems if
   /// "foo/bar" doesn't exist.
-  Future _validateIntermediateChildrenAsync(String dir,
-      List<FileSystemEntity> entities) async {
+  Future _validateIntermediateChildrenAsync(
+      String dir, List<FileSystemEntity> entities) async {
     if (_caseSensitive) return;
 
     for (var sequence in children.keys) {
       var child = children[sequence];
       if (!child._isIntermediate) continue;
-      if (entities.any((entity) =>
-          sequence.matches(p.relative(entity.path, from: dir)))) {
+      if (entities.any(
+          (entity) => sequence.matches(p.relative(entity.path, from: dir)))) {
         continue;
       }
 
@@ -426,8 +427,9 @@
           .where((sequence) => sequence.matches(basename))
           .expand((sequence) {
         try {
-          return children[sequence].listSync(
-              p.join(dir, basename), followLinks: followLinks).toList();
+          return children[sequence]
+              .listSync(p.join(dir, basename), followLinks: followLinks)
+              .toList();
         } on FileSystemException catch (error) {
           // Ignore errors from directories not existing. We do this here so
           // that we only ignore warnings below wild cards. For example, the
@@ -452,14 +454,14 @@
   ///
   /// This ensures that listing "foo/bar/*" fails on case-sensitive systems if
   /// "foo/bar" doesn't exist.
-  void _validateIntermediateChildrenSync(String dir,
-      List<FileSystemEntity> entities) {
+  void _validateIntermediateChildrenSync(
+      String dir, List<FileSystemEntity> entities) {
     if (_caseSensitive) return;
 
     children.forEach((sequence, child) {
       if (!child._isIntermediate) return;
-      if (entities.any((entity) =>
-          sequence.matches(p.relative(entity.path, from: dir)))) {
+      if (entities.any(
+          (entity) => sequence.matches(p.relative(entity.path, from: dir)))) {
         return;
       }
 
@@ -467,8 +469,7 @@
       // directory to force `dart:io` to throw an error. This allows us to
       // ensure that listing "foo/bar/*" fails on case-sensitive systems if
       // "foo/bar" doesn't exist.
-      child
-          .listSync(p.join(dir, (sequence.nodes.single as LiteralNode).text));
+      child.listSync(p.join(dir, (sequence.nodes.single as LiteralNode).text));
     });
   }
 
diff --git a/lib/src/parser.dart b/lib/src/parser.dart
index d3c7e1d..a4e840c 100644
--- a/lib/src/parser.dart
+++ b/lib/src/parser.dart
@@ -120,8 +120,7 @@
 
         if (end < char) {
           _scanner.error("Range out of order.",
-              position: start,
-              length: _scanner.position - start);
+              position: start, length: _scanner.position - start);
         }
         ranges.add(new Range(char, end));
       } else {
@@ -156,8 +155,8 @@
   AstNode _parseLiteral({bool inOptions: false}) {
     // If we're in an options block, we want to stop parsing as soon as we hit a
     // comma. Otherwise, commas are fair game for literals.
-    var regExp = new RegExp(
-        inOptions ? r'[^*{[?\\}\],()]*' : r'[^*{[?\\}\]()]*');
+    var regExp =
+        new RegExp(inOptions ? r'[^*{[?\\}\],()]*' : r'[^*{[?\\}\]()]*');
 
     _scanner.scan(regExp);
     var buffer = new StringBuffer()..write(_scanner.lastMatch[0]);
diff --git a/lib/src/stream_pool.dart b/lib/src/stream_pool.dart
index 817d57a..cce94ed 100644
--- a/lib/src/stream_pool.dart
+++ b/lib/src/stream_pool.dart
@@ -46,8 +46,7 @@
   void add(Stream<T> stream) {
     if (_subscriptions.containsKey(stream)) return;
     _subscriptions[stream] = stream.listen(_controller.add,
-        onError: _controller.addError,
-        onDone: () => remove(stream));
+        onError: _controller.addError, onDone: () => remove(stream));
   }
 
   /// Removes [stream] as a member of this pool.
diff --git a/lib/src/utils.dart b/lib/src/utils.dart
index 94f6a05..13c0b99 100644
--- a/lib/src/utils.dart
+++ b/lib/src/utils.dart
@@ -18,14 +18,13 @@
   Range(this.min, this.max);
 
   /// Returns a range that covers only [value].
-  Range.singleton(int value)
-      : this(value, value);
+  Range.singleton(int value) : this(value, value);
 
   /// Whether [this] contains [value].
   bool contains(int value) => value >= min && value <= max;
 
-  bool operator==(Object other) => other is Range &&
-      other.min == min && other.max == max;
+  bool operator ==(Object other) =>
+      other is Range && other.min == min && other.max == max;
 
   int get hashCode => 3 * min + 7 * max;
 }
diff --git a/test/list_test.dart b/test/list_test.dart
index 9a389e8..8729a38 100644
--- a/test/list_test.dart
+++ b/test/list_test.dart
@@ -2,6 +2,7 @@
 // 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';
 
@@ -10,6 +11,7 @@
 import 'package:path/path.dart' as p;
 import 'package:scheduled_test/descriptor.dart' as d;
 import 'package:scheduled_test/scheduled_test.dart';
+import 'package:test/test.dart' show TestOn;
 
 String sandbox;
 
@@ -19,10 +21,7 @@
 
     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();
   });
 
@@ -41,7 +40,8 @@
     test("reports exceptions for non-existent case-insensitive directories",
         () {
       schedule(() {
-        expect(new Glob("non/existent/**", caseSensitive: false).list().toList(),
+        expect(
+            new Glob("non/existent/**", caseSensitive: false).list().toList(),
             throwsA(new isInstanceOf<FileSystemException>()));
       });
     });
@@ -105,10 +105,10 @@
 
     group("star", () {
       test("lists within filenames but not across directories", () {
-        expect(list("foo/b*"), completion(unorderedEquals([
-          p.join("foo", "bar"),
-          p.join("foo", "baz")
-        ])));
+        expect(
+            list("foo/b*"),
+            completion(
+                unorderedEquals([p.join("foo", "bar"), p.join("foo", "baz")])));
       });
 
       test("lists the empy string", () {
@@ -118,10 +118,10 @@
 
     group("double star", () {
       test("lists within filenames", () {
-        expect(list("foo/baz/**"), completion(unorderedEquals([
-          p.join("foo", "baz", "qux"),
-          p.join("foo", "baz", "bang")
-        ])));
+        expect(
+            list("foo/baz/**"),
+            completion(unorderedEquals(
+                [p.join("foo", "baz", "qux"), p.join("foo", "baz", "bang")])));
       });
 
       test("lists the empty string", () {
@@ -129,49 +129,52 @@
       });
 
       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")
-        ])));
+        expect(
+            list("foo/**"),
+            completion(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")
-        ])));
+        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("lists recursively in the middle of a glob", () {
         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(
+            list("deep/**/?/?"),
+            completion(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")
-        ])));
+        expect(
+            list("foo/ba?"),
+            completion(
+                unorderedEquals([p.join("foo", "bar"), p.join("foo", "baz")])));
       });
 
       test("doesn't match a separator", () {
@@ -181,17 +184,17 @@
 
     group("range", () {
       test("matches a range of characters", () {
-        expect(list("foo/ba[a-z]"), completion(unorderedEquals([
-          p.join("foo", "bar"),
-          p.join("foo", "baz")
-        ])));
+        expect(
+            list("foo/ba[a-z]"),
+            completion(
+                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")
-        ])));
+        expect(
+            list("foo/ba[rz]"),
+            completion(
+                unorderedEquals([p.join("foo", "bar"), p.join("foo", "baz")])));
       });
 
       test("doesn't match outside its range", () {
@@ -220,23 +223,21 @@
         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(
+          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")
+          ])));
     });
 
     group("with symlinks", () {
@@ -248,11 +249,13 @@
       });
 
       test("follows symlinks by default", () {
-        expect(list("dir/**"), completion(unorderedEquals([
-          p.join("dir", "link"),
-          p.join("dir", "link", "bang"),
-          p.join("dir", "link", "qux")
-        ])));
+        expect(
+            list("dir/**"),
+            completion(unorderedEquals([
+              p.join("dir", "link"),
+              p.join("dir", "link", "bang"),
+              p.join("dir", "link", "qux")
+            ])));
       });
 
       test("doesn't follow symlinks with followLinks: false", () {
@@ -270,38 +273,38 @@
     });
 
     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")
-      ])));
+      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("lists an absolute glob", () {
       expect(schedule(() {
-        var pattern = separatorToForwardSlash(
-            p.absolute(p.join(sandbox, 'foo/baz/**')));
+        var pattern =
+            separatorToForwardSlash(p.absolute(p.join(sandbox, 'foo/baz/**')));
 
         return list(pattern);
-      }), completion(unorderedEquals([
-        p.join("foo", "baz", "bang"),
-        p.join("foo", "baz", "qux")
-      ])));
+      }),
+          completion(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/**')));
+        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")
-      ])));
+      }),
+          completion(unorderedEquals(
+              [p.join("foo", "baz", "bang"), p.join("foo", "baz", "qux")])));
     }, skip: "Broken by sdk#28015.");
 
     test("lists a subdirectory that sometimes exists", () {
diff --git a/test/match_test.dart b/test/match_test.dart
index 13dc7d6..50d6f13 100644
--- a/test/match_test.dart
+++ b/test/match_test.dart
@@ -11,8 +11,9 @@
     "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", () {
@@ -22,8 +23,8 @@
   });
 
   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", () {
@@ -237,7 +238,7 @@
   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);
@@ -270,20 +271,20 @@
 
     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)));
 
@@ -301,26 +302,26 @@
 
     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))));
     });
   });