diff --git a/.travis.yml b/.travis.yml
new file mode 100644
index 0000000..db953f8
--- /dev/null
+++ b/.travis.yml
@@ -0,0 +1,20 @@
+language: dart
+sudo: false
+dart:
+  - dev
+  - stable
+cache:
+  directories:
+    - $HOME/.pub-cache
+dart_task:
+  - test: --platform vm
+  - test: --platform chrome
+  - test: --platform dartium
+    install_dartium: true
+  - dartanalyzer
+  - dartfmt
+matrix:
+  # Only run dartfmt checks with stable.
+  exclude:
+    - dart: dev
+      dart_task: dartfmt
diff --git a/lib/src/algorithms.dart b/lib/src/algorithms.dart
index d8ca102..fbf33ec 100644
--- a/lib/src/algorithms.dart
+++ b/lib/src/algorithms.dart
@@ -79,7 +79,6 @@
   }
 }
 
-
 /// Reverses a list, or a part of a list, in-place.
 void reverse(List list, [int start = 0, int end = null]) {
   if (end == null) end = list.length;
@@ -110,8 +109,8 @@
 ///
 /// This insertion sort is stable: Equal elements end up in the same order
 /// as they started in.
-void insertionSort/*<T>*/(List/*<T>*/ list, {int compare(/*=T*/ a, /*=T*/ b),
-    int start: 0, int end}) {
+void insertionSort/*<T>*/(List/*<T>*/ list,
+    {int compare(/*=T*/ a, /*=T*/ b), int start: 0, int end}) {
   // If the same method could have both positional and named optional
   // parameters, this should be (list, [start, end], {compare}).
   compare ??= defaultCompare/*<T>*/();
@@ -153,8 +152,8 @@
 ///
 /// This merge sort is stable: Equal elements end up in the same order
 /// as they started in.
-void mergeSort/*<T>*/(List/*<T>*/ list, {int start: 0, int end,
-    int compare(/*=T*/ a, /*=T*/ b)}) {
+void mergeSort/*<T>*/(List/*<T>*/ list,
+    {int start: 0, int end, int compare(/*=T*/ a, /*=T*/ b)}) {
   end ??= list.length;
   compare ??= defaultCompare/*<T>*/();
 
@@ -178,18 +177,20 @@
   _mergeSort(list, compare, middle, end, scratchSpace, 0);
   int firstTarget = end - firstLength;
   _mergeSort(list, compare, start, middle, list, firstTarget);
-  _merge(compare,
-         list, firstTarget, end,
-         scratchSpace, 0, secondLength,
-         list, start);
+  _merge(compare, list, firstTarget, end, scratchSpace, 0, secondLength, list,
+      start);
 }
 
 /// Performs an insertion sort into a potentially different list than the
 /// one containing the original values.
 ///
 /// It will work in-place as well.
-void _movingInsertionSort/*<T>*/(List/*<T>*/ list,
-    int compare(/*=T*/ a, /*=T*/ b), int start, int end, List/*<T>*/ target,
+void _movingInsertionSort/*<T>*/(
+    List/*<T>*/ list,
+    int compare(/*=T*/ a, /*=T*/ b),
+    int start,
+    int end,
+    List/*<T>*/ target,
     int targetOffset) {
   int length = end - start;
   if (length == 0) return;
@@ -206,8 +207,7 @@
         min = mid + 1;
       }
     }
-    target.setRange(min + 1, targetOffset + i + 1,
-                    target, min);
+    target.setRange(min + 1, targetOffset + i + 1, target, min);
     target[min] = element;
   }
 }
@@ -232,16 +232,12 @@
   // Here secondLength >= firstLength (differs by at most one).
   int targetMiddle = targetOffset + firstLength;
   // Sort the second half into the end of the target area.
-  _mergeSort(list, compare, middle, end,
-             target, targetMiddle);
+  _mergeSort(list, compare, middle, end, target, targetMiddle);
   // Sort the first half into the end of the source area.
-  _mergeSort(list, compare, start, middle,
-             list, middle);
+  _mergeSort(list, compare, start, middle, list, middle);
   // Merge the two parts into the target area.
-  _merge(compare,
-         list, middle, middle + firstLength,
-         target, targetMiddle, targetMiddle + secondLength,
-         target, targetOffset);
+  _merge(compare, list, middle, middle + firstLength, target, targetMiddle,
+      targetMiddle + secondLength, target, targetOffset);
 }
 
 /// Merges two lists into a target list.
@@ -252,10 +248,16 @@
 /// For equal object, elements from [firstList] are always preferred.
 /// This allows the merge to be stable if the first list contains elements
 /// that started out earlier than the ones in [secondList]
-void _merge/*<T>*/(int compare(/*=T*/ a, /*=T*/ b),
-    List/*<T>*/ firstList, int firstStart, int firstEnd,
-    List/*<T>*/ secondList, int secondStart, int secondEnd,
-    List/*<T>*/ target, int targetOffset) {
+void _merge/*<T>*/(
+    int compare(/*=T*/ a, /*=T*/ b),
+    List/*<T>*/ firstList,
+    int firstStart,
+    int firstEnd,
+    List/*<T>*/ secondList,
+    int secondStart,
+    int secondEnd,
+    List/*<T>*/ target,
+    int targetOffset) {
   // No empty lists reaches here.
   assert(firstStart < firstEnd);
   assert(secondStart < secondEnd);
@@ -266,7 +268,7 @@
   while (true) {
     if (compare(firstElement, secondElement) <= 0) {
       target[targetOffset++] = firstElement;
-      if (cursor1 == firstEnd) break;  // Flushing second list after loop.
+      if (cursor1 == firstEnd) break; // Flushing second list after loop.
       firstElement = firstList[cursor1++];
     } else {
       target[targetOffset++] = secondElement;
@@ -283,6 +285,6 @@
   }
   // First list empties first. Reached by break above.
   target[targetOffset++] = secondElement;
-  target.setRange(targetOffset, targetOffset + (secondEnd - cursor2),
-      secondList, cursor2);
+  target.setRange(
+      targetOffset, targetOffset + (secondEnd - cursor2), secondList, cursor2);
 }
diff --git a/lib/src/canonicalized_map.dart b/lib/src/canonicalized_map.dart
index cc78105..a8af43a 100644
--- a/lib/src/canonicalized_map.dart
+++ b/lib/src/canonicalized_map.dart
@@ -48,7 +48,7 @@
   /// methods that take arbitrary objects. It can be used to filter out keys
   /// that can't be canonicalized.
   CanonicalizedMap.from(Map<K, V> other, C canonicalize(K key),
-                        {bool isValidKey(Object key)})
+      {bool isValidKey(Object key)})
       : _canonicalize = canonicalize,
         _isValidKeyFn = isValidKey {
     addAll(other);
@@ -94,8 +94,9 @@
   int get length => _base.length;
 
   V putIfAbsent(K key, V ifAbsent()) {
-    return _base.putIfAbsent(_canonicalize(key),
-        () => new Pair(key, ifAbsent())).last;
+    return _base
+        .putIfAbsent(_canonicalize(key), () => new Pair(key, ifAbsent()))
+        .last;
   }
 
   V remove(Object key) {
@@ -108,6 +109,7 @@
 
   String toString() => Maps.mapToString(this);
 
-  bool _isValidKey(Object key) => (key == null || key is K) &&
+  bool _isValidKey(Object key) =>
+      (key == null || key is K) &&
       (_isValidKeyFn == null || _isValidKeyFn(key));
 }
diff --git a/lib/src/comparators.dart b/lib/src/comparators.dart
index b0824a8..5fc55b2 100644
--- a/lib/src/comparators.dart
+++ b/lib/src/comparators.dart
@@ -3,11 +3,11 @@
 // BSD-style license that can be found in the LICENSE file.
 
 // Character constants.
-const int _zero         = 0x30;
-const int _upperCaseA   = 0x41;
-const int _upperCaseZ   = 0x5a;
-const int _lowerCaseA   = 0x61;
-const int _lowerCaseZ   = 0x7a;
+const int _zero = 0x30;
+const int _upperCaseA = 0x41;
+const int _upperCaseZ = 0x5a;
+const int _lowerCaseA = 0x61;
+const int _lowerCaseZ = 0x7a;
 const int _asciiCaseBit = 0x20;
 
 /// Checks if strings [a] and [b] differ only on the case of ASCII letters.
@@ -43,7 +43,6 @@
   return true;
 }
 
-
 /// Hash code for a string which is compatible with [equalsIgnoreAsciiCase].
 ///
 /// The hash code is unaffected by changing the case of ASCII letters, but
@@ -69,7 +68,6 @@
   return 0x1fffffff & (hash + ((0x00003fff & hash) << 15));
 }
 
-
 /// Compares [a] and [b] lexically, converting ASCII letters to upper case.
 ///
 /// Comparison treats all lower-case ASCII letters as upper-case letters,
@@ -107,7 +105,6 @@
   return defaultResult.sign;
 }
 
-
 /// Compares [a] and [b] lexically, converting ASCII letters to lower case.
 ///
 /// Comparison treats all upper-case ASCII letters as lower-case letters,
@@ -258,8 +255,7 @@
 /// is a digit, and if so, the the one with the digit is the greater number.
 ///
 /// Otherwise just returns the difference between [aChar] and [bChar].
-int _compareNaturally(
-    String a, String b, int index, int aChar, int bChar) {
+int _compareNaturally(String a, String b, int index, int aChar, int bChar) {
   assert(aChar != bChar);
   var aIsDigit = _isDigit(aChar);
   var bIsDigit = _isDigit(bChar);
@@ -302,14 +298,14 @@
   if (aChar == _zero) {
     do {
       aIndex++;
-      if (aIndex == a.length) return -1;  // number in a is zero, b is not.
+      if (aIndex == a.length) return -1; // number in a is zero, b is not.
       aChar = a.codeUnitAt(aIndex);
     } while (aChar == _zero);
     if (!_isDigit(aChar)) return -1;
   } else if (bChar == _zero) {
     do {
       bIndex++;
-      if (bIndex == b.length) return 1;  // number in b is zero, a is not.
+      if (bIndex == b.length) return 1; // number in b is zero, a is not.
       bChar = b.codeUnitAt(bIndex);
     } while (bChar == _zero);
     if (!_isDigit(bChar)) return 1;
@@ -343,7 +339,7 @@
       // bChar is non-digit, so a has longer number.
       return 1;
     } else if (bIsDigit) {
-      return -1;  // b has longer number.
+      return -1; // b has longer number.
     } else {
       // Neither is digit, so numbers had same numerical value.
       // Fall back on number of leading zeros
diff --git a/lib/src/empty_unmodifiable_set.dart b/lib/src/empty_unmodifiable_set.dart
index 581532f..69212a7 100644
--- a/lib/src/empty_unmodifiable_set.dart
+++ b/lib/src/empty_unmodifiable_set.dart
@@ -11,7 +11,7 @@
 /// An unmodifiable, empty set that can have a const constructor.
 class EmptyUnmodifiableSet<E> extends IterableBase<E>
     implements UnmodifiableSetView<E> {
-  static /*=T*/ _throw/*<T>*/() {
+  static/*=T*/ _throw/*<T>*/() {
     throw new UnsupportedError("Cannot modify an unmodifiable Set");
   }
 
@@ -37,4 +37,3 @@
   void retainWhere(bool test(E element)) => _throw();
   void retainAll(Iterable<Object> elements) => _throw();
 }
-
diff --git a/lib/src/equality.dart b/lib/src/equality.dart
index 3b10176..aa5effa 100644
--- a/lib/src/equality.dart
+++ b/lib/src/equality.dart
@@ -96,8 +96,8 @@
 /// Two iterables are equal if they have the same elements in the same order.
 class IterableEquality<E> implements Equality<Iterable<E>> {
   final Equality<E> _elementEquality;
-  const IterableEquality([Equality<E> elementEquality =
-                              const DefaultEquality()])
+  const IterableEquality(
+      [Equality<E> elementEquality = const DefaultEquality()])
       : _elementEquality = elementEquality;
 
   bool equals(Iterable<E> elements1, Iterable<E> elements2) {
@@ -238,8 +238,7 @@
 /// This equality behaves the same as [UnorderedIterableEquality] except that
 /// it expects sets instead of iterables as arguments.
 class SetEquality<E> extends _UnorderedEquality<E, Set<E>> {
-  const SetEquality(
-      [Equality<E> elementEquality = const DefaultEquality()])
+  const SetEquality([Equality<E> elementEquality = const DefaultEquality()])
       : super(elementEquality);
 
   bool isValidKey(Object o) => o is Set<E>;
@@ -257,14 +256,14 @@
 
   int get hashCode =>
       (3 * equality._keyEquality.hash(key) +
-       7 * equality._valueEquality.hash(value)) & _HASH_MASK;
+          7 * equality._valueEquality.hash(value)) &
+      _HASH_MASK;
 
-  bool operator==(Object other) {
+  bool operator ==(Object other) {
     if (other is! _MapEntry) return false;
     _MapEntry otherEntry = other;
     return equality._keyEquality.equals(key, otherEntry.key) &&
-           equality._valueEquality.equals(value, otherEntry.value);
-
+        equality._valueEquality.equals(value, otherEntry.value);
   }
 }
 
@@ -275,9 +274,11 @@
 class MapEquality<K, V> implements Equality<Map<K, V>> {
   final Equality<K> _keyEquality;
   final Equality<V> _valueEquality;
-  const MapEquality({ Equality<K> keys : const DefaultEquality(),
-                      Equality<V> values : const DefaultEquality() })
-      : _keyEquality = keys, _valueEquality = values;
+  const MapEquality(
+      {Equality<K> keys: const DefaultEquality(),
+      Equality<V> values: const DefaultEquality()})
+      : _keyEquality = keys,
+        _valueEquality = values;
 
   bool equals(Map<K, V> e1, Map<K, V> e2) {
     if (identical(e1, e2)) return true;
@@ -377,14 +378,16 @@
   final Equality _base;
   final bool _unordered;
   const DeepCollectionEquality([Equality base = const DefaultEquality()])
-      : _base = base, _unordered = false;
+      : _base = base,
+        _unordered = false;
 
   /// Creates a deep equality on collections where the order of lists and
   /// iterables are not considered important. That is, lists and iterables are
   /// treated as unordered iterables.
   const DeepCollectionEquality.unordered(
       [Equality base = const DefaultEquality()])
-      : _base = base, _unordered = true;
+      : _base = base,
+        _unordered = true;
 
   bool equals(e1, e2) {
     if (e1 is Set) {
diff --git a/lib/src/equality_map.dart b/lib/src/equality_map.dart
index 686e5bd..14f074c 100644
--- a/lib/src/equality_map.dart
+++ b/lib/src/equality_map.dart
@@ -29,4 +29,3 @@
     addAll(other);
   }
 }
-
diff --git a/lib/src/equality_set.dart b/lib/src/equality_set.dart
index b0582ce..6f6a426 100644
--- a/lib/src/equality_set.dart
+++ b/lib/src/equality_set.dart
@@ -29,4 +29,3 @@
     addAll(other);
   }
 }
-
diff --git a/lib/src/functions.dart b/lib/src/functions.dart
index 6e5bb0a..14fff53 100644
--- a/lib/src/functions.dart
+++ b/lib/src/functions.dart
@@ -9,7 +9,7 @@
 
 // TODO(nweiz): When sdk#26488 is fixed, use overloads to ensure that if [key]
 // or [value] isn't passed, `K2`/`V2` defaults to `K1`/`V1`, respectively.
-/// Creates a new map from [map] with new keys and values. 
+/// Creates a new map from [map] with new keys and values.
 ///
 /// The return values of [key] are used as the keys and the return values of
 /// [value] are used as the values for the new map.
@@ -19,7 +19,7 @@
   key ??= (mapKey, _) => mapKey as dynamic/*=K2*/;
   value ??= (_, mapValue) => mapValue as dynamic/*=V2*/;
 
-  var result = /*<K2, V2>*/{};
+  var result = /*<K2, V2>*/ {};
   map.forEach((mapKey, mapValue) {
     result[key(mapKey, mapValue)] = value(mapKey, mapValue);
   });
@@ -33,13 +33,12 @@
 /// values. If [value] is omitted, the value from [map2] is used.
 Map/*<K, V>*/ mergeMaps/*<K, V>*/(Map/*<K, V>*/ map1, Map/*<K, V>*/ map2,
     {/*=V*/ value(/*=V*/ value1, /*=V*/ value2)}) {
-  var result = new Map/*<K, V>*/.from(map1);
+  var result = new Map/*<K, V>*/ .from(map1);
   if (value == null) return result..addAll(map2);
 
   map2.forEach((key, mapValue) {
-    result[key] = result.containsKey(key)
-        ? value(result[key], mapValue)
-        : mapValue;
+    result[key] =
+        result.containsKey(key) ? value(result[key], mapValue) : mapValue;
   });
   return result;
 }
@@ -49,9 +48,10 @@
 /// Returns a map from keys computed by [key] to a list of all values for which
 /// [key] returns that key. The values appear in the list in the same relative
 /// order as in [values].
-Map<dynamic/*=T*/, List/*<S>*/> groupBy/*<S, T>*/(Iterable/*<S>*/ values,
+Map<dynamic/*=T*/, List/*<S>*/ > groupBy/*<S, T>*/(
+    Iterable/*<S>*/ values,
     /*=T*/ key(/*=S*/ element)) {
-  var map = /*<T, List<S>>*/{};
+  var map = /*<T, List<S>>*/ {};
   for (var element in values) {
     var list = map.putIfAbsent(key(element), () => []);
     list.add(element);
@@ -114,15 +114,15 @@
 /// that vertex has no outgoing edges. This isn't checked, but if it's not
 /// satisfied, the function may crash or provide unexpected output. For example,
 /// `{"a": ["b"]}` is not valid, but `{"a": ["b"], "b": []}` is.
-Map<dynamic/*=T*/, Set/*<T>*/> transitiveClosure/*<T>*/(
-    Map<dynamic/*=T*/, Iterable/*<T>*/> graph) {
+Map<dynamic/*=T*/, Set/*<T>*/ > transitiveClosure/*<T>*/(
+    Map<dynamic/*=T*/, Iterable/*<T>*/ > graph) {
   // This uses [Warshall's algorithm][], modified not to add a vertex from each
   // node to itself.
   //
   // [Warshall's algorithm]: https://en.wikipedia.org/wiki/Floyd%E2%80%93Warshall_algorithm#Applications_and_generalizations.
-  var result = /*<T, Set>*/{};
+  var result = /*<T, Set>*/ {};
   graph.forEach((vertex, edges) {
-    result[vertex] = new Set/*<T>*/.from(edges);
+    result[vertex] = new Set/*<T>*/ .from(edges);
   });
 
   // Lists are faster to iterate than maps, so we create a list since we're
@@ -154,14 +154,14 @@
 /// that vertex has no outgoing edges. This isn't checked, but if it's not
 /// satisfied, the function may crash or provide unexpected output. For example,
 /// `{"a": ["b"]}` is not valid, but `{"a": ["b"], "b": []}` is.
-List<Set/*<T>*/> stronglyConnectedComponents/*<T>*/(
-    Map<dynamic/*=T*/, Iterable/*<T>*/> graph) {
+List<Set/*<T>*/ > stronglyConnectedComponents/*<T>*/(
+    Map<dynamic/*=T*/, Iterable/*<T>*/ > graph) {
   // This uses [Tarjan's algorithm][].
   //
   // [Tarjan's algorithm]: https://en.wikipedia.org/wiki/Tarjan%27s_strongly_connected_components_algorithm
   var index = 0;
-  var stack = /*<T>*/[];
-  var result = /*<Set<T>>*/[];
+  var stack = /*<T>*/ [];
+  var result = /*<Set<T>>*/ [];
 
   // The order of these doesn't matter, so we use un-linked implementations to
   // avoid unnecessary overhead.
diff --git a/lib/src/iterable_zip.dart b/lib/src/iterable_zip.dart
index 638c686..b983437 100644
--- a/lib/src/iterable_zip.dart
+++ b/lib/src/iterable_zip.dart
@@ -16,8 +16,7 @@
 class IterableZip<T> extends IterableBase<List<T>> {
   final Iterable<Iterable<T>> _iterables;
 
-  IterableZip(Iterable<Iterable<T>> iterables)
-      : this._iterables = iterables;
+  IterableZip(Iterable<Iterable<T>> iterables) : this._iterables = iterables;
 
   /// Returns an iterator that combines values of the iterables' iterators
   /// as long as they all have values.
diff --git a/lib/src/priority_queue.dart b/lib/src/priority_queue.dart
index e0f65b4..84c43c2 100644
--- a/lib/src/priority_queue.dart
+++ b/lib/src/priority_queue.dart
@@ -276,8 +276,8 @@
         }
         // Then go to the right sibling of the left-child.
         position += 1;
-      } while (position > _length);  // Happens if last element is a left child.
-    } while (position != 1);  // At root again. Happens for right-most element.
+      } while (position > _length); // Happens if last element is a left child.
+    } while (position != 1); // At root again. Happens for right-most element.
     return -1;
   }
 
diff --git a/lib/src/queue_list.dart b/lib/src/queue_list.dart
index bf75f33..73c1f66 100644
--- a/lib/src/queue_list.dart
+++ b/lib/src/queue_list.dart
@@ -19,7 +19,9 @@
   ///
   /// If [initialCapacity] is given, prepare the queue for at least that many
   /// elements.
-  QueueList([int initialCapacity]) : _head = 0, _tail = 0 {
+  QueueList([int initialCapacity])
+      : _head = 0,
+        _tail = 0 {
     if (initialCapacity == null || initialCapacity < _INITIAL_CAPACITY) {
       initialCapacity = _INITIAL_CAPACITY;
     } else if (!_isPowerOf2(initialCapacity)) {
@@ -82,7 +84,9 @@
 
   // Queue interface.
 
-  void addLast(E element) { _add(element); }
+  void addLast(E element) {
+    _add(element);
+  }
 
   void addFirst(E element) {
     _head = (_head - 1) & (_table.length - 1);
@@ -125,7 +129,7 @@
     int newTail = _tail + delta; // [delta] is negative.
     if (newTail >= 0) {
       _table.fillRange(newTail, _tail, null);
-    } else { 
+    } else {
       newTail += _table.length;
       _table.fillRange(0, _tail, null);
       _table.fillRange(newTail, _table.length, null);
@@ -141,7 +145,7 @@
     return _table[(_head + index) & (_table.length - 1)];
   }
 
-  void operator[]=(int index, E value) {
+  void operator []=(int index, E value) {
     if (index < 0 || index >= length) {
       throw new RangeError("Index $index must be in the range [0..$length).");
     }
@@ -164,7 +168,7 @@
   static int _nextPowerOf2(int number) {
     assert(number > 0);
     number = (number << 1) - 1;
-    for(;;) {
+    for (;;) {
       int nextNumber = number & (number - 1);
       if (nextNumber == 0) return number;
       number = nextNumber;
diff --git a/lib/src/typed_wrappers.dart b/lib/src/typed_wrappers.dart
index 9416d81..d4c2fde 100644
--- a/lib/src/typed_wrappers.dart
+++ b/lib/src/typed_wrappers.dart
@@ -66,7 +66,7 @@
   E get single => _base.single as E;
 
   E singleWhere(bool test(E element)) =>
-    _base.singleWhere(_validate(test)) as E;
+      _base.singleWhere(_validate(test)) as E;
 
   Iterable<E> skip(int n) => new TypeSafeIterable<E>(_base.skip(n));
 
diff --git a/lib/src/unmodifiable_wrappers.dart b/lib/src/unmodifiable_wrappers.dart
index 5efbee4..9e74348 100644
--- a/lib/src/unmodifiable_wrappers.dart
+++ b/lib/src/unmodifiable_wrappers.dart
@@ -19,14 +19,14 @@
 /// You can, for example, [sort] the list.
 /// Permitted operations defer to the wrapped list.
 class NonGrowableListView<E> extends DelegatingList<E>
-                             with NonGrowableListMixin<E> {
+    with NonGrowableListMixin<E> {
   NonGrowableListView(List<E> listBase) : super(listBase);
 }
 
 /// Mixin class that implements a throwing version of all list operations that
 /// change the List's length.
 abstract class NonGrowableListMixin<E> implements List<E> {
-  static /*=T*/ _throw/*<T>*/() {
+  static/*=T*/ _throw/*<T>*/() {
     throw new UnsupportedError(
         "Cannot change the length of a fixed-length list");
   }
@@ -105,7 +105,7 @@
 /// Mixin class that implements a throwing version of all set operations that
 /// change the Set.
 abstract class UnmodifiableSetMixin<E> implements Set<E> {
-  static /*=T*/ _throw/*<T>*/() {
+  static/*=T*/ _throw/*<T>*/() {
     throw new UnsupportedError("Cannot modify an unmodifiable Set");
   }
 
@@ -145,7 +145,7 @@
 /// Mixin class that implements a throwing version of all map operations that
 /// change the Map.
 abstract class UnmodifiableMapMixin<K, V> implements Map<K, V> {
-  static /*=T*/ _throw/*<T>*/() {
+  static/*=T*/ _throw/*<T>*/() {
     throw new UnsupportedError("Cannot modify an unmodifiable Map");
   }
 
diff --git a/lib/src/wrappers.dart b/lib/src/wrappers.dart
index 92760f6..1b917de 100644
--- a/lib/src/wrappers.dart
+++ b/lib/src/wrappers.dart
@@ -106,7 +106,6 @@
       base is Iterable/*<E>*/ ? base : new TypeSafeIterable/*<E>*/(base);
 }
 
-
 /// A [List] that delegates all operations to a base list.
 ///
 /// This class can be used to hide non-`List` methods of a list object, or it
@@ -217,7 +216,6 @@
   List<E> sublist(int start, [int end]) => _listBase.sublist(start, end);
 }
 
-
 /// A [Set] that delegates all operations to a base set.
 ///
 /// This class can be used to hide non-`Set` methods of a set object, or it can
@@ -328,9 +326,13 @@
 
   bool remove(Object object) => _baseQueue.remove(object);
 
-  void removeWhere(bool test(E element)) { _baseQueue.removeWhere(test); }
+  void removeWhere(bool test(E element)) {
+    _baseQueue.removeWhere(test);
+  }
 
-  void retainWhere(bool test(E element)) { _baseQueue.retainWhere(test); }
+  void retainWhere(bool test(E element)) {
+    _baseQueue.retainWhere(test);
+  }
 
   E removeFirst() => _baseQueue.removeFirst();
 
@@ -450,8 +452,8 @@
 
   /// Throws an [UnsupportedError] since there's no corresponding method for
   /// [Map]s.
-  E lookup(E element) => throw new UnsupportedError(
-      "MapKeySet doesn't support lookup().");
+  E lookup(E element) =>
+      throw new UnsupportedError("MapKeySet doesn't support lookup().");
 
   /// Returns a new set which contains all the elements of [this] and [other].
   ///
diff --git a/lib/wrappers.dart b/lib/wrappers.dart
index 541456e..13031f5 100644
--- a/lib/wrappers.dart
+++ b/lib/wrappers.dart
@@ -9,4 +9,3 @@
 export "src/canonicalized_map.dart";
 export "src/unmodifiable_wrappers.dart";
 export "src/wrappers.dart";
-
diff --git a/test/algorithms_test.dart b/test/algorithms_test.dart
index 6e6f630..dbd2633 100644
--- a/test/algorithms_test.dart
+++ b/test/algorithms_test.dart
@@ -43,18 +43,19 @@
       if (count == 10) fail("Shuffle didn't change order.");
     } while (true);
   });
-  test("Shuffle sublist", (){
+  test("Shuffle sublist", () {
     List l = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16];
     List c = l.toList();
     shuffle(l, 4, 12);
-    expect(const IterableEquality().equals(l.getRange(0, 4),
-                                           c.getRange(0, 4)), isTrue);
-    expect(const IterableEquality().equals(l.getRange(12, 16),
-                                           c.getRange(12, 16)), isTrue);
-    expect(const UnorderedIterableEquality().equals(l.getRange(4, 12),
-                                                    c.getRange(4, 12)),
-           isTrue);
-
+    expect(const IterableEquality().equals(l.getRange(0, 4), c.getRange(0, 4)),
+        isTrue);
+    expect(
+        const IterableEquality().equals(l.getRange(12, 16), c.getRange(12, 16)),
+        isTrue);
+    expect(
+        const UnorderedIterableEquality()
+            .equals(l.getRange(4, 12), c.getRange(4, 12)),
+        isTrue);
   });
 
   test("binsearch0", () {
@@ -158,7 +159,7 @@
     for (int i = 0; i < 25; i++) {
       List list = new List(i);
       for (int j = 0; j < i; j++) {
-        list[j] = random.nextInt(25);  // Expect some equal elements.
+        list[j] = random.nextInt(25); // Expect some equal elements.
       }
       insertionSort(list);
       for (int j = 1; j < i; j++) {
@@ -196,7 +197,7 @@
     for (int i = 0; i < 250; i += 1) {
       List list = new List(i);
       for (int j = 0; j < i; j++) {
-        list[j] = random.nextInt(i);  // Expect some equal elements.
+        list[j] = random.nextInt(i); // Expect some equal elements.
       }
       mergeSort(list);
       for (int j = 1; j < i; j++) {
@@ -314,6 +315,7 @@
   final int id;
   C(this.id);
 }
+
 int compareC(C one, C other) => one.id - other.id;
 
 class OC implements Comparable<OC> {
diff --git a/test/canonicalized_map_test.dart b/test/canonicalized_map_test.dart
index 19e6a48..437e44f 100644
--- a/test/canonicalized_map_test.dart
+++ b/test/canonicalized_map_test.dart
@@ -30,32 +30,20 @@
     });
 
     test("canonicalizes keys for addAll", () {
-      map.addAll({
-        "1": "value 1",
-        "2": "value 2",
-        "3": "value 3"
-      });
+      map.addAll({"1": "value 1", "2": "value 2", "3": "value 3"});
       expect(map["01"], equals("value 1"));
       expect(map["02"], equals("value 2"));
       expect(map["03"], equals("value 3"));
     });
 
     test("uses the final value for addAll collisions", () {
-      map.addAll({
-        "1": "value 1",
-        "01": "value 2",
-        "001": "value 3"
-      });
+      map.addAll({"1": "value 1", "01": "value 2", "001": "value 3"});
       expect(map.length, equals(1));
       expect(map["0001"], equals("value 3"));
     });
 
     test("clear clears the map", () {
-      map.addAll({
-        "1": "value 1",
-        "2": "value 2",
-        "3": "value 3"
-      });
+      map.addAll({"1": "value 1", "2": "value 2", "3": "value 3"});
       expect(map, isNot(isEmpty));
       map.clear();
       expect(map, isEmpty);
@@ -73,8 +61,8 @@
 
     test("canonicalizes keys for putIfAbsent", () {
       map["1"] = "value";
-      expect(map.putIfAbsent("01", () => throw "shouldn't run"),
-             equals("value"));
+      expect(
+          map.putIfAbsent("01", () => throw "shouldn't run"), equals("value"));
       expect(map.putIfAbsent("2", () => "new value"), equals("new value"));
     });
 
@@ -137,12 +125,8 @@
     });
 
     test("values returns all values in the map", () {
-      map.addAll({
-        "1": "value 1",
-        "01": "value 01",
-        "2": "value 2",
-        "03": "value 03"
-      });
+      map.addAll(
+          {"1": "value 1", "01": "value 01", "2": "value 2", "03": "value 03"});
 
       expect(map.values, equals(["value 01", "value 2", "value 03"]));
     });
@@ -150,22 +134,16 @@
 
   group("CanonicalizedMap.from", () {
     test("canonicalizes its keys", () {
-      var map = new CanonicalizedMap.from({
-        "1": "value 1",
-        "2": "value 2",
-        "3": "value 3"
-      }, int.parse);
+      var map = new CanonicalizedMap.from(
+          {"1": "value 1", "2": "value 2", "3": "value 3"}, int.parse);
       expect(map["01"], equals("value 1"));
       expect(map["02"], equals("value 2"));
       expect(map["03"], equals("value 3"));
     });
 
     test("uses the final value for collisions", () {
-      var map = new CanonicalizedMap.from({
-        "1": "value 1",
-        "01": "value 2",
-        "001": "value 3"
-      }, int.parse);
+      var map = new CanonicalizedMap.from(
+          {"1": "value 1", "01": "value 2", "001": "value 3"}, int.parse);
       expect(map.length, equals(1));
       expect(map["0001"], equals("value 3"));
     });
diff --git a/test/combined_wrapper/iterable_test.dart b/test/combined_wrapper/iterable_test.dart
index a473a02..3301821 100644
--- a/test/combined_wrapper/iterable_test.dart
+++ b/test/combined_wrapper/iterable_test.dart
@@ -16,8 +16,8 @@
   });
 
   test('should combine multiple iterables with some empty ones', () {
-    var combined = new CombinedIterableView(
-        [iterable1, [], iterable2, [], iterable3, []]);
+    var combined =
+        new CombinedIterableView([iterable1, [], iterable2, [], iterable3, []]);
     expect(combined, [0, 1, 2, 3, 4, 5, 6, 7, 8]);
   });
 
diff --git a/test/combined_wrapper/list_test.dart b/test/combined_wrapper/list_test.dart
index e072097..1a00f32 100644
--- a/test/combined_wrapper/list_test.dart
+++ b/test/combined_wrapper/list_test.dart
@@ -14,13 +14,11 @@
   var concat = []..addAll(list1)..addAll(list2)..addAll(list3);
 
   // In every way possible this should test the same as an UnmodifiableListView.
-  common.testUnmodifiableList(concat, new CombinedListView(
-    [list1, list2, list3]
-  ), 'combineLists');
+  common.testUnmodifiableList(
+      concat, new CombinedListView([list1, list2, list3]), 'combineLists');
 
-  common.testUnmodifiableList(concat, new CombinedListView(
-    [list1, [], list2, [], list3, []]
-  ), 'combineLists');
+  common.testUnmodifiableList(concat,
+      new CombinedListView([list1, [], list2, [], list3, []]), 'combineLists');
 
   test('should function as an empty list when no lists are passed', () {
     var empty = new CombinedListView([]);
diff --git a/test/combined_wrapper/map_test.dart b/test/combined_wrapper/map_test.dart
index c447373..832fe36 100644
--- a/test/combined_wrapper/map_test.dart
+++ b/test/combined_wrapper/map_test.dart
@@ -14,13 +14,13 @@
   var concat = {}..addAll(map1)..addAll(map2)..addAll(map3);
 
   // In every way possible this should test the same as an UnmodifiableMapView.
-  common.testReadMap(concat, new CombinedMapView(
-      [map1, map2, map3]
-  ), 'CombinedMapView');
+  common.testReadMap(
+      concat, new CombinedMapView([map1, map2, map3]), 'CombinedMapView');
 
-  common.testReadMap(concat, new CombinedMapView(
-      [map1, {}, map2, {}, map3, {}]
-  ), 'CombinedMapView (some empty)');
+  common.testReadMap(
+      concat,
+      new CombinedMapView([map1, {}, map2, {}, map3, {}]),
+      'CombinedMapView (some empty)');
 
   test('should function as an empty map when no maps are passed', () {
     var empty = new CombinedMapView([]);
diff --git a/test/comparators_test.dart b/test/comparators_test.dart
index 169c688..aa868d9 100644
--- a/test/comparators_test.dart
+++ b/test/comparators_test.dart
@@ -57,63 +57,63 @@
     "~"
   ];
 
-  sortedBy(compare) => strings.toList()..shuffle()..sort(compare);
+  sortedBy(compare) => strings.toList()
+    ..shuffle()
+    ..sort(compare);
 
   test("String.compareTo", () {
     expect(sortedBy(null), strings);
   });
   test("compareAsciiLowerCase", () {
-    expect(sortedBy(compareAsciiLowerCase),
-           sortedBy((a, b) {
-             int delta = a.toLowerCase().compareTo(b.toLowerCase());
-             if (delta != 0) return delta;
-             if (a == b) return 0;
-             return a.compareTo(b);
-           }));
+    expect(sortedBy(compareAsciiLowerCase), sortedBy((a, b) {
+      int delta = a.toLowerCase().compareTo(b.toLowerCase());
+      if (delta != 0) return delta;
+      if (a == b) return 0;
+      return a.compareTo(b);
+    }));
   });
   test("compareAsciiUpperCase", () {
-    expect(sortedBy(compareAsciiUpperCase),
-           sortedBy((a, b) {
-             int delta = a.toUpperCase().compareTo(b.toUpperCase());
-             if (delta != 0) return delta;
-             if (a == b) return 0;
-             return a.compareTo(b);
-           }));
+    expect(sortedBy(compareAsciiUpperCase), sortedBy((a, b) {
+      int delta = a.toUpperCase().compareTo(b.toUpperCase());
+      if (delta != 0) return delta;
+      if (a == b) return 0;
+      return a.compareTo(b);
+    }));
   });
 
   // Replace any digit sequence by ("0", value, length) as char codes.
   // This will sort alphabetically (by charcode) the way digits sort
   // numerically, and the leading 0 means it sorts like a digit
   // compared to non-digits.
-  replaceNumbers(String string) => string.replaceAllMapped(new RegExp(r"\d+"), (m) {
-    var digits = m[0];
-    return new String.fromCharCodes([0x30, int.parse(digits), digits.length]);
-  });
+  replaceNumbers(String string) =>
+      string.replaceAllMapped(new RegExp(r"\d+"), (m) {
+        var digits = m[0];
+        return new String.fromCharCodes(
+            [0x30, int.parse(digits), digits.length]);
+      });
 
   test("compareNatural", () {
     expect(sortedBy(compareNatural),
-           sortedBy((a, b) => replaceNumbers(a).compareTo(replaceNumbers(b))));
+        sortedBy((a, b) => replaceNumbers(a).compareTo(replaceNumbers(b))));
   });
 
   test("compareAsciiLowerCaseNatural", () {
-    expect(sortedBy(compareAsciiLowerCaseNatural),
-           sortedBy((a, b) {
-             int delta = replaceNumbers(a.toLowerCase()).compareTo(
-                             replaceNumbers(b.toLowerCase()));
-             if (delta != 0) return delta;
-             if (a == b) return 0;
-             return a.compareTo(b);
-           }));
+    expect(sortedBy(compareAsciiLowerCaseNatural), sortedBy((a, b) {
+      int delta = replaceNumbers(a.toLowerCase())
+          .compareTo(replaceNumbers(b.toLowerCase()));
+      if (delta != 0) return delta;
+      if (a == b) return 0;
+      return a.compareTo(b);
+    }));
   });
 
   test("compareAsciiUpperCaseNatural", () {
-    expect(sortedBy(compareAsciiUpperCaseNatural),
-           sortedBy((a, b) {
-             int delta = replaceNumbers(a.toUpperCase()).compareTo(
-                             replaceNumbers(b.toUpperCase()));
-             if (delta != 0) return delta;
-             if (a == b) return 0;
-             return a.compareTo(b);
-           }));
+    expect(sortedBy(compareAsciiUpperCaseNatural), sortedBy((a, b) {
+      int delta = replaceNumbers(a.toUpperCase())
+          .compareTo(replaceNumbers(b.toUpperCase()));
+      if (delta != 0) return delta;
+      if (a == b) return 0;
+      return a.compareTo(b);
+    }));
   });
 }
diff --git a/test/equality_set_test.dart b/test/equality_set_test.dart
index 1b20684..a326b31 100644
--- a/test/equality_set_test.dart
+++ b/test/equality_set_test.dart
@@ -35,8 +35,8 @@
     var list5 = [1, 2, 3];
     var list6 = [1, 2, 3];
 
-    var set = new EqualitySet.from(const IterableEquality(),
-        [list1, list2, list3, list4, list5, list6]);
+    var set = new EqualitySet.from(
+        const IterableEquality(), [list1, list2, list3, list4, list5, list6]);
 
     expect(set, contains(same(list1)));
     expect(set, contains(same(list2)));
diff --git a/test/equality_test.dart b/test/equality_test.dart
index bdf8711..f407fab 100644
--- a/test/equality_test.dart
+++ b/test/equality_test.dart
@@ -32,31 +32,27 @@
   });
 
   test("ListEquality", () {
-    expect(const ListEquality().equals(list1, list2),
-           isTrue);
+    expect(const ListEquality().equals(list1, list2), isTrue);
     Equality listId = const ListEquality(const IdentityEquality());
     expect(listId.equals(list1, list2), isFalse);
   });
 
   test("ListInequality length", () {
     var list4 = [o(1), o(2), o(3), o(4), o(5), o(6)];
-    expect(const ListEquality().equals(list1, list4),
-           isFalse);
+    expect(const ListEquality().equals(list1, list4), isFalse);
     expect(const ListEquality(const IdentityEquality()).equals(list1, list4),
-           isFalse);
+        isFalse);
   });
 
   test("ListInequality value", () {
     var list5 = [o(1), o(2), o(3), o(4), o(6)];
-    expect(const ListEquality().equals(list1, list5),
-           isFalse);
+    expect(const ListEquality().equals(list1, list5), isFalse);
     expect(const ListEquality(const IdentityEquality()).equals(list1, list5),
-           isFalse);
+        isFalse);
   });
 
   test("UnorderedIterableEquality", () {
-    expect(const UnorderedIterableEquality().equals(list1, list3),
-           isTrue);
+    expect(const UnorderedIterableEquality().equals(list1, list3), isTrue);
     Equality uniterId =
         const UnorderedIterableEquality(const IdentityEquality());
     expect(uniterId.equals(list1, list3), isFalse);
@@ -64,20 +60,20 @@
 
   test("UnorderedIterableInequality length", () {
     var list6 = [o(1), o(3), o(5), o(4), o(2), o(1)];
-    expect(const UnorderedIterableEquality().equals(list1, list6),
-           isFalse);
-    expect(const UnorderedIterableEquality(const IdentityEquality())
-               .equals(list1, list6),
-           isFalse);
+    expect(const UnorderedIterableEquality().equals(list1, list6), isFalse);
+    expect(
+        const UnorderedIterableEquality(const IdentityEquality())
+            .equals(list1, list6),
+        isFalse);
   });
 
   test("UnorderedIterableInequality values", () {
     var list7 = [o(1), o(3), o(5), o(4), o(6)];
-    expect(const UnorderedIterableEquality().equals(list1, list7),
-           isFalse);
-    expect(const UnorderedIterableEquality(const IdentityEquality())
-               .equals(list1, list7),
-           isFalse);
+    expect(const UnorderedIterableEquality().equals(list1, list7), isFalse);
+    expect(
+        const UnorderedIterableEquality(const IdentityEquality())
+            .equals(list1, list7),
+        isFalse);
   });
 
   test("SetEquality", () {
@@ -92,26 +88,36 @@
     var list8 = [o(1), o(3), o(5), o(4), o(2), o(6)];
     var set1 = new HashSet.from(list1);
     var set2 = new LinkedHashSet.from(list8);
-    expect(const SetEquality().equals(set1, set2),
-           isFalse);
+    expect(const SetEquality().equals(set1, set2), isFalse);
     expect(const SetEquality(const IdentityEquality()).equals(set1, set2),
-           isFalse);
+        isFalse);
   });
 
   test("SetInequality value", () {
     var list7 = [o(1), o(3), o(5), o(4), o(6)];
     var set1 = new HashSet.from(list1);
     var set2 = new LinkedHashSet.from(list7);
-    expect(const SetEquality().equals(set1, set2),
-           isFalse);
+    expect(const SetEquality().equals(set1, set2), isFalse);
     expect(const SetEquality(const IdentityEquality()).equals(set1, set2),
-           isFalse);
+        isFalse);
   });
 
-  var map1a = {"x": [o(1), o(2), o(3)], "y": [true, false, null]};
-  var map1b = {"x": [o(4), o(5), o(6)], "y": [false, true, null]};
-  var map2a = {"x": [o(3), o(2), o(1)], "y": [false, true, null]};
-  var map2b = {"x": [o(6), o(5), o(4)], "y": [null, false, true]};
+  var map1a = {
+    "x": [o(1), o(2), o(3)],
+    "y": [true, false, null]
+  };
+  var map1b = {
+    "x": [o(4), o(5), o(6)],
+    "y": [false, true, null]
+  };
+  var map2a = {
+    "x": [o(3), o(2), o(1)],
+    "y": [false, true, null]
+  };
+  var map2b = {
+    "x": [o(6), o(5), o(4)],
+    "y": [null, false, true]
+  };
   var l1 = [map1a, map1b];
   var l2 = [map2a, map2b];
   var s1 = new Set<Map>.from(l1);
@@ -119,46 +125,29 @@
 
   test("RecursiveEquality", () {
     const unordered = const UnorderedIterableEquality();
-    expect(unordered.equals(map1a["x"], map2a["x"]),
-        isTrue);
-    expect(unordered.equals(map1a["y"], map2a["y"]),
-        isTrue);
-    expect(unordered.equals(map1b["x"], map2b["x"]),
-        isTrue);
-    expect(unordered.equals(map1b["y"], map2b["y"]),
-        isTrue);
+    expect(unordered.equals(map1a["x"], map2a["x"]), isTrue);
+    expect(unordered.equals(map1a["y"], map2a["y"]), isTrue);
+    expect(unordered.equals(map1b["x"], map2b["x"]), isTrue);
+    expect(unordered.equals(map1b["y"], map2b["y"]), isTrue);
     const mapval = const MapEquality(values: unordered);
-    expect(
-        mapval.equals(map1a, map2a),
-        isTrue);
-    expect(mapval.equals(map1b, map2b),
-        isTrue);
+    expect(mapval.equals(map1a, map2a), isTrue);
+    expect(mapval.equals(map1b, map2b), isTrue);
     const listmapval = const ListEquality(mapval);
-    expect(listmapval.equals(l1, l2),
-        isTrue);
+    expect(listmapval.equals(l1, l2), isTrue);
     const setmapval = const SetEquality<Map>(mapval);
-    expect(setmapval.equals(s1, s2),
-        isTrue);
+    expect(setmapval.equals(s1, s2), isTrue);
   });
 
   test("DeepEquality", () {
     var colleq = const DeepCollectionEquality.unordered();
-    expect(colleq.equals(map1a["x"], map2a["x"]),
-        isTrue);
-    expect(colleq.equals(map1a["y"], map2a["y"]),
-        isTrue);
-    expect(colleq.equals(map1b["x"], map2b["x"]),
-        isTrue);
-    expect(colleq.equals(map1b["y"], map2b["y"]),
-        isTrue);
-    expect(colleq.equals(map1a, map2a),
-        isTrue);
-    expect(colleq.equals(map1b, map2b),
-        isTrue);
-    expect(colleq.equals(l1, l2),
-        isTrue);
-    expect(colleq.equals(s1, s2),
-        isTrue);
+    expect(colleq.equals(map1a["x"], map2a["x"]), isTrue);
+    expect(colleq.equals(map1a["y"], map2a["y"]), isTrue);
+    expect(colleq.equals(map1b["x"], map2b["x"]), isTrue);
+    expect(colleq.equals(map1b["y"], map2b["y"]), isTrue);
+    expect(colleq.equals(map1a, map2a), isTrue);
+    expect(colleq.equals(map1b, map2b), isTrue);
+    expect(colleq.equals(l1, l2), isTrue);
+    expect(colleq.equals(s1, s2), isTrue);
   });
 
   test("CaseInsensitiveEquality", () {
@@ -177,22 +166,15 @@
   });
 
   group("EqualityBy should use a derived value for ", () {
-    var firstEquality = new EqualityBy<List<String>, String>(
-        (e) => e.first);
+    var firstEquality = new EqualityBy<List<String>, String>((e) => e.first);
     var firstInsensitiveEquality = new EqualityBy<List<String>, String>(
         (e) => e.first, const CaseInsensitiveEquality());
     var firstObjectEquality = new EqualityBy<List<Object>, Object>(
         (e) => e.first, const IterableEquality());
 
     test("equality", () {
-      expect(
-          firstEquality.equals(
-              ["foo", "foo"], ["foo", "bar"]),
-          isTrue);
-      expect(
-          firstEquality.equals(
-              ["foo", "foo"], ["bar", "bar"]),
-          isFalse);
+      expect(firstEquality.equals(["foo", "foo"], ["foo", "bar"]), isTrue);
+      expect(firstEquality.equals(["foo", "foo"], ["bar", "bar"]), isFalse);
     });
 
     test("equality with an inner equality", () {
@@ -205,8 +187,7 @@
     });
 
     test("hash with an inner equality", () {
-      expect(
-          firstInsensitiveEquality.hash(["fOo"]),
+      expect(firstInsensitiveEquality.hash(["fOo"]),
           const CaseInsensitiveEquality().hash("foo"));
     });
 
@@ -231,6 +212,6 @@
   final Comparable id;
   const Element(this.id);
   int get hashCode => id.hashCode;
-  bool operator==(Object other) => other is Element && id == other.id;
+  bool operator ==(Object other) => other is Element && id == other.id;
   int compareTo(other) => id.compareTo(other.id);
 }
diff --git a/test/functions_test.dart b/test/functions_test.dart
index 8eeba0a..d75f8cf 100644
--- a/test/functions_test.dart
+++ b/test/functions_test.dart
@@ -62,7 +62,8 @@
     });
 
     test("uses the callback to merge values", () {
-      expect(mergeMaps({"foo": 1, "bar": 2}, {"bar": 3, "baz": 4},
+      expect(
+          mergeMaps({"foo": 1, "bar": 2}, {"bar": 3, "baz": 4},
               value: (value1, value2) => value1 + value2),
           equals({"foo": 1, "bar": 5, "baz": 4}));
     });
@@ -76,7 +77,11 @@
     test("groups elements by the function's return value", () {
       expect(
           groupBy(["foo", "bar", "baz", "bop", "qux"], (string) => string[1]),
-          equals({"o": ["foo", "bop"], "a": ["bar", "baz"], "u": ["qux"]}));
+          equals({
+            "o": ["foo", "bop"],
+            "a": ["bar", "baz"],
+            "u": ["qux"]
+          }));
     });
   });
 
@@ -88,20 +93,29 @@
           isNull);
     });
 
-    test("returns the element for which the ordering function returns the "
+    test(
+        "returns the element for which the ordering function returns the "
         "smallest value", () {
       expect(
-          minBy(
-              [{"foo": 3}, {"foo": 5}, {"foo": 4}, {"foo": 1}, {"foo": 2}],
-              (map) => map["foo"]),
+          minBy([
+            {"foo": 3},
+            {"foo": 5},
+            {"foo": 4},
+            {"foo": 1},
+            {"foo": 2}
+          ], (map) => map["foo"]),
           equals({"foo": 1}));
     });
 
     test("uses a custom comparator if provided", () {
       expect(
-          minBy(
-              [{"foo": 3}, {"foo": 5}, {"foo": 4}, {"foo": 1}, {"foo": 2}],
-              (map) => map,
+          minBy([
+            {"foo": 3},
+            {"foo": 5},
+            {"foo": 4},
+            {"foo": 1},
+            {"foo": 2}
+          ], (map) => map,
               compare: (map1, map2) => map1["foo"].compareTo(map2["foo"])),
           equals({"foo": 1}));
     });
@@ -115,20 +129,29 @@
           isNull);
     });
 
-    test("returns the element for which the ordering function returns the "
+    test(
+        "returns the element for which the ordering function returns the "
         "largest value", () {
       expect(
-          maxBy(
-              [{"foo": 3}, {"foo": 5}, {"foo": 4}, {"foo": 1}, {"foo": 2}],
-              (map) => map["foo"]),
+          maxBy([
+            {"foo": 3},
+            {"foo": 5},
+            {"foo": 4},
+            {"foo": 1},
+            {"foo": 2}
+          ], (map) => map["foo"]),
           equals({"foo": 5}));
     });
 
     test("uses a custom comparator if provided", () {
       expect(
-          maxBy(
-              [{"foo": 3}, {"foo": 5}, {"foo": 4}, {"foo": 1}, {"foo": 2}],
-              (map) => map,
+          maxBy([
+            {"foo": 3},
+            {"foo": 5},
+            {"foo": 4},
+            {"foo": 1},
+            {"foo": 2}
+          ], (map) => map,
               compare: (map1, map2) => map1["foo"].compareTo(map2["foo"])),
           equals({"foo": 5}));
     });
@@ -140,45 +163,51 @@
     });
 
     test("returns the input when there are no transitive connections", () {
-      expect(transitiveClosure({
-        "foo": ["bar"],
-        "bar": [],
-        "bang": ["qux", "zap"],
-        "qux": [],
-        "zap": []
-      }), equals({
-        "foo": ["bar"],
-        "bar": [],
-        "bang": ["qux", "zap"],
-        "qux": [],
-        "zap": []
-      }));
+      expect(
+          transitiveClosure({
+            "foo": ["bar"],
+            "bar": [],
+            "bang": ["qux", "zap"],
+            "qux": [],
+            "zap": []
+          }),
+          equals({
+            "foo": ["bar"],
+            "bar": [],
+            "bang": ["qux", "zap"],
+            "qux": [],
+            "zap": []
+          }));
     });
 
     test("flattens transitive connections", () {
-      expect(transitiveClosure({
-        "qux": [],
-        "bar": ["baz"],
-        "baz": ["qux"],
-        "foo": ["bar"]
-      }), equals({
-        "foo": ["bar", "baz", "qux"],
-        "bar": ["baz", "qux"],
-        "baz": ["qux"],
-        "qux": []
-      }));
+      expect(
+          transitiveClosure({
+            "qux": [],
+            "bar": ["baz"],
+            "baz": ["qux"],
+            "foo": ["bar"]
+          }),
+          equals({
+            "foo": ["bar", "baz", "qux"],
+            "bar": ["baz", "qux"],
+            "baz": ["qux"],
+            "qux": []
+          }));
     });
 
     test("handles loops", () {
-      expect(transitiveClosure({
-        "foo": ["bar"],
-        "bar": ["baz"],
-        "baz": ["foo"]
-      }), equals({
-        "foo": ["bar", "baz", "foo"],
-        "bar": ["baz", "foo", "bar"],
-        "baz": ["foo", "bar", "baz"]
-      }));
+      expect(
+          transitiveClosure({
+            "foo": ["bar"],
+            "bar": ["baz"],
+            "baz": ["foo"]
+          }),
+          equals({
+            "foo": ["bar", "baz", "foo"],
+            "bar": ["baz", "foo", "bar"],
+            "baz": ["foo", "bar", "baz"]
+          }));
     });
   });
 
@@ -188,90 +217,116 @@
     });
 
     test("returns one set for a singleton graph", () {
-      expect(stronglyConnectedComponents({"a": []}),
-          equals([new Set.from(["a"])]));
+      expect(
+          stronglyConnectedComponents({"a": []}),
+          equals([
+            new Set.from(["a"])
+          ]));
     });
 
     test("returns two sets for a two-element tree", () {
-      expect(stronglyConnectedComponents({"a": ["b"], "b": []}),
-          equals([new Set.from(["a"]), new Set.from(["b"])]));
+      expect(
+          stronglyConnectedComponents({
+            "a": ["b"],
+            "b": []
+          }),
+          equals([
+            new Set.from(["a"]),
+            new Set.from(["b"])
+          ]));
     });
 
     test("returns one set for a two-element loop", () {
-      expect(stronglyConnectedComponents({"a": ["b"], "b": ["a"]}),
-          equals([new Set.from(["a", "b"])]));
+      expect(
+          stronglyConnectedComponents({
+            "a": ["b"],
+            "b": ["a"]
+          }),
+          equals([
+            new Set.from(["a", "b"])
+          ]));
     });
 
     test("returns individual vertices for a tree", () {
-      expect(stronglyConnectedComponents({
-        "foo": ["bar"],
-        "bar": ["baz", "bang"],
-        "baz": ["qux"],
-        "bang": ["zap"],
-        "qux": [],
-        "zap": []
-      }), equals([
-        // This is expected to return *a* topological ordering, but this isn't
-        // the only valid one. If the function implementation changes in the
-        // future, this test may need to be updated.
-        new Set.from(["foo"]),
-        new Set.from(["bar"]),
-        new Set.from(["bang"]),
-        new Set.from(["zap"]),
-        new Set.from(["baz"]),
-        new Set.from(["qux"])
-      ]));
+      expect(
+          stronglyConnectedComponents({
+            "foo": ["bar"],
+            "bar": ["baz", "bang"],
+            "baz": ["qux"],
+            "bang": ["zap"],
+            "qux": [],
+            "zap": []
+          }),
+          equals([
+            // This is expected to return *a* topological ordering, but this isn't
+            // the only valid one. If the function implementation changes in the
+            // future, this test may need to be updated.
+            new Set.from(["foo"]),
+            new Set.from(["bar"]),
+            new Set.from(["bang"]),
+            new Set.from(["zap"]),
+            new Set.from(["baz"]),
+            new Set.from(["qux"])
+          ]));
     });
 
     test("returns a single set for a fully cyclic graph", () {
-      expect(stronglyConnectedComponents({
-        "foo": ["bar"],
-        "bar": ["baz"],
-        "baz": ["bang"],
-        "bang": ["foo"]
-      }), equals([new Set.from(["foo", "bar", "baz", "bang"])]));
+      expect(
+          stronglyConnectedComponents({
+            "foo": ["bar"],
+            "bar": ["baz"],
+            "baz": ["bang"],
+            "bang": ["foo"]
+          }),
+          equals([
+            new Set.from(["foo", "bar", "baz", "bang"])
+          ]));
     });
 
     test("returns separate sets for each strongly connected component", () {
       // https://en.wikipedia.org/wiki/Strongly_connected_component#/media/File:Scc.png
-      expect(stronglyConnectedComponents({
-        "a": ["b"],
-        "b": ["c", "e", "f"],
-        "c": ["d", "g"],
-        "d": ["c", "h"],
-        "e": ["a", "f"],
-        "f": ["g"],
-        "g": ["f"],
-        "h": ["g", "d"]
-      }), equals([
-        // This is expected to return *a* topological ordering, but this isn't
-        // the only valid one. If the function implementation changes in the
-        // future, this test may need to be updated.
-        new Set.from(["a", "b", "e"]),
-        new Set.from(["c", "d", "h"]),
-        new Set.from(["f", "g"]),
-      ]));
+      expect(
+          stronglyConnectedComponents({
+            "a": ["b"],
+            "b": ["c", "e", "f"],
+            "c": ["d", "g"],
+            "d": ["c", "h"],
+            "e": ["a", "f"],
+            "f": ["g"],
+            "g": ["f"],
+            "h": ["g", "d"]
+          }),
+          equals([
+            // This is expected to return *a* topological ordering, but this isn't
+            // the only valid one. If the function implementation changes in the
+            // future, this test may need to be updated.
+            new Set.from(["a", "b", "e"]),
+            new Set.from(["c", "d", "h"]),
+            new Set.from(["f", "g"]),
+          ]));
     });
 
     test("always returns components in topological order", () {
-      expect(stronglyConnectedComponents({
-        "bar": ["baz", "bang"],
-        "zap": [],
-        "baz": ["qux"],
-        "qux": [],
-        "foo": ["bar"],
-        "bang": ["zap"]
-      }), equals([
-        // This is expected to return *a* topological ordering, but this isn't
-        // the only valid one. If the function implementation changes in the
-        // future, this test may need to be updated.
-        new Set.from(["foo"]),
-        new Set.from(["bar"]),
-        new Set.from(["bang"]),
-        new Set.from(["zap"]),
-        new Set.from(["baz"]),
-        new Set.from(["qux"])
-      ]));
+      expect(
+          stronglyConnectedComponents({
+            "bar": ["baz", "bang"],
+            "zap": [],
+            "baz": ["qux"],
+            "qux": [],
+            "foo": ["bar"],
+            "bang": ["zap"]
+          }),
+          equals([
+            // This is expected to return *a* topological ordering, but this isn't
+            // the only valid one. If the function implementation changes in the
+            // future, this test may need to be updated.
+            new Set.from(["foo"]),
+            new Set.from(["bar"]),
+            new Set.from(["bang"]),
+            new Set.from(["zap"]),
+            new Set.from(["baz"]),
+            new Set.from(["qux"])
+          ]));
     });
   });
 }
diff --git a/test/ignore_ascii_case_test.dart b/test/ignore_ascii_case_test.dart
index 787f76f..6aee455 100644
--- a/test/ignore_ascii_case_test.dart
+++ b/test/ignore_ascii_case_test.dart
@@ -34,7 +34,7 @@
         var reason = "$s1 =?= $s2";
         expect(equalsIgnoreAsciiCase(s1, s2), true, reason: reason);
         expect(hashIgnoreAsciiCase(s1), hashIgnoreAsciiCase(s2),
-               reason: reason);
+            reason: reason);
       }
     }
 
@@ -44,8 +44,9 @@
 
     testChars(char1, char2, areEqual) {
       expect(equalsIgnoreAsciiCase(char1, char2), areEqual,
-             reason: "$char1 ${areEqual ? "=" : "!"}= $char2");
+          reason: "$char1 ${areEqual ? "=" : "!"}= $char2");
     }
+
     for (int i = 0; i < upperCaseLetters.length; i++) {
       for (int j = 0; i < upperCaseLetters.length; i++) {
         testChars(upperCaseLetters[i], upperCaseLetters[j], i == j);
@@ -55,4 +56,4 @@
       }
     }
   });
-}
\ No newline at end of file
+}
diff --git a/test/iterable_zip_test.dart b/test/iterable_zip_test.dart
index 0679171..d4d5484 100644
--- a/test/iterable_zip_test.dart
+++ b/test/iterable_zip_test.dart
@@ -15,40 +15,103 @@
 
 main() {
   test("Basic", () {
-    expect(new IterableZip([[1, 2, 3], [4, 5, 6], [7, 8, 9]]),
-           equals([[1, 4, 7], [2, 5, 8], [3, 6, 9]]));
+    expect(
+        new IterableZip([
+          [1, 2, 3],
+          [4, 5, 6],
+          [7, 8, 9]
+        ]),
+        equals([
+          [1, 4, 7],
+          [2, 5, 8],
+          [3, 6, 9]
+        ]));
   });
 
   test("Uneven length 1", () {
-    expect(new IterableZip([[1, 2, 3, 99, 100], [4, 5, 6], [7, 8, 9]]),
-           equals([[1, 4, 7], [2, 5, 8], [3, 6, 9]]));
+    expect(
+        new IterableZip([
+          [1, 2, 3, 99, 100],
+          [4, 5, 6],
+          [7, 8, 9]
+        ]),
+        equals([
+          [1, 4, 7],
+          [2, 5, 8],
+          [3, 6, 9]
+        ]));
   });
 
   test("Uneven length 2", () {
-    expect(new IterableZip([[1, 2, 3], [4, 5, 6, 99, 100], [7, 8, 9]]),
-           equals([[1, 4, 7], [2, 5, 8], [3, 6, 9]]));
+    expect(
+        new IterableZip([
+          [1, 2, 3],
+          [4, 5, 6, 99, 100],
+          [7, 8, 9]
+        ]),
+        equals([
+          [1, 4, 7],
+          [2, 5, 8],
+          [3, 6, 9]
+        ]));
   });
 
   test("Uneven length 3", () {
-    expect(new IterableZip([[1, 2, 3], [4, 5, 6], [7, 8, 9, 99, 100]]),
-           equals([[1, 4, 7], [2, 5, 8], [3, 6, 9]]));
+    expect(
+        new IterableZip([
+          [1, 2, 3],
+          [4, 5, 6],
+          [7, 8, 9, 99, 100]
+        ]),
+        equals([
+          [1, 4, 7],
+          [2, 5, 8],
+          [3, 6, 9]
+        ]));
   });
 
   test("Uneven length 3", () {
-    expect(new IterableZip([[1, 2, 3, 98], [4, 5, 6], [7, 8, 9, 99, 100]]),
-           equals([[1, 4, 7], [2, 5, 8], [3, 6, 9]]));
+    expect(
+        new IterableZip([
+          [1, 2, 3, 98],
+          [4, 5, 6],
+          [7, 8, 9, 99, 100]
+        ]),
+        equals([
+          [1, 4, 7],
+          [2, 5, 8],
+          [3, 6, 9]
+        ]));
   });
 
   test("Empty 1", () {
-    expect(new IterableZip([[], [4, 5, 6], [7, 8, 9]]), equals([]));
+    expect(
+        new IterableZip([
+          [],
+          [4, 5, 6],
+          [7, 8, 9]
+        ]),
+        equals([]));
   });
 
   test("Empty 2", () {
-    expect(new IterableZip([[1, 2, 3], [], [7, 8, 9]]), equals([]));
+    expect(
+        new IterableZip([
+          [1, 2, 3],
+          [],
+          [7, 8, 9]
+        ]),
+        equals([]));
   });
 
   test("Empty 3", () {
-    expect(new IterableZip([[1, 2, 3], [4, 5, 6], []]), equals([]));
+    expect(
+        new IterableZip([
+          [1, 2, 3],
+          [4, 5, 6],
+          []
+        ]),
+        equals([]));
   });
 
   test("Empty source", () {
@@ -56,59 +119,98 @@
   });
 
   test("Single Source", () {
-    expect(new IterableZip([[1, 2, 3]]), equals([[1], [2], [3]]));
+    expect(
+        new IterableZip([
+          [1, 2, 3]
+        ]),
+        equals([
+          [1],
+          [2],
+          [3]
+        ]));
   });
 
   test("Not-lists", () {
     // Use other iterables than list literals.
     Iterable it1 = [1, 2, 3, 4, 5, 6].where((x) => x < 4);
     Set it2 = new LinkedHashSet()..add(4)..add(5)..add(6);
-    Iterable it3 = (new LinkedHashMap()..[7] = 0 ..[8] = 0 ..[9] = 0).keys;
+    Iterable it3 = (new LinkedHashMap()
+          ..[7] = 0
+          ..[8] = 0
+          ..[9] = 0)
+        .keys;
     Iterable<Iterable> allIts =
         new Iterable.generate(3, (i) => [it1, it2, it3][i]);
-    expect(new IterableZip(allIts),
-           equals([[1, 4, 7], [2, 5, 8], [3, 6, 9]]));
+    expect(
+        new IterableZip(allIts),
+        equals([
+          [1, 4, 7],
+          [2, 5, 8],
+          [3, 6, 9]
+        ]));
   });
 
   test("Error 1", () {
-    expect(() => new IterableZip([iterError([1, 2, 3], 2),
-                                  [4, 5, 6],
-                                  [7, 8, 9]]).toList(),
-           throwsA(equals("BAD")));
+    expect(
+        () => new IterableZip([
+              iterError([1, 2, 3], 2),
+              [4, 5, 6],
+              [7, 8, 9]
+            ]).toList(),
+        throwsA(equals("BAD")));
   });
 
   test("Error 2", () {
-    expect(() => new IterableZip([[1, 2, 3],
-                                  iterError([4, 5, 6], 5),
-                                  [7, 8, 9]]).toList(),
-           throwsA(equals("BAD")));
+    expect(
+        () => new IterableZip([
+              [1, 2, 3],
+              iterError([4, 5, 6], 5),
+              [7, 8, 9]
+            ]).toList(),
+        throwsA(equals("BAD")));
   });
 
   test("Error 3", () {
-    expect(() => new IterableZip([[1, 2, 3],
-                                  [4, 5, 6],
-                                  iterError([7, 8, 9], 8)]).toList(),
-           throwsA(equals("BAD")));
+    expect(
+        () => new IterableZip([
+              [1, 2, 3],
+              [4, 5, 6],
+              iterError([7, 8, 9], 8)
+            ]).toList(),
+        throwsA(equals("BAD")));
   });
 
   test("Error at end", () {
-    expect(() => new IterableZip([[1, 2, 3],
-                                  iterError([4, 5, 6], 6),
-                                  [7, 8, 9]]).toList(),
-           throwsA(equals("BAD")));
+    expect(
+        () => new IterableZip([
+              [1, 2, 3],
+              iterError([4, 5, 6], 6),
+              [7, 8, 9]
+            ]).toList(),
+        throwsA(equals("BAD")));
   });
 
   test("Error before first end", () {
-    expect(() => new IterableZip([iterError([1, 2, 3, 4], 4),
-                                  [4, 5, 6],
-                                  [7, 8, 9]]).toList(),
-           throwsA(equals("BAD")));
+    expect(
+        () => new IterableZip([
+              iterError([1, 2, 3, 4], 4),
+              [4, 5, 6],
+              [7, 8, 9]
+            ]).toList(),
+        throwsA(equals("BAD")));
   });
 
   test("Error after first end", () {
-    expect(new IterableZip([[1, 2, 3],
-                            [4, 5, 6],
-                            iterError([7, 8, 9, 10], 10)]),
-           equals([[1, 4, 7], [2, 5, 8], [3, 6, 9]]));
+    expect(
+        new IterableZip([
+          [1, 2, 3],
+          [4, 5, 6],
+          iterError([7, 8, 9, 10], 10)
+        ]),
+        equals([
+          [1, 4, 7],
+          [2, 5, 8],
+          [3, 6, 9]
+        ]));
   });
 }
diff --git a/test/priority_queue_test.dart b/test/priority_queue_test.dart
index 3131b15..0e493e5 100644
--- a/test/priority_queue_test.dart
+++ b/test/priority_queue_test.dart
@@ -16,8 +16,8 @@
 
 void testDefault() {
   test('new PriorityQueue() returns a HeapPriorityQueue', () {
-    expect(new PriorityQueue<int>(),
-        new isInstanceOf<HeapPriorityQueue<int>>());
+    expect(
+        new PriorityQueue<int>(), new isInstanceOf<HeapPriorityQueue<int>>());
   });
   testInt(() => new PriorityQueue<int>());
   testCustom((comparator) => new PriorityQueue<C>(comparator));
@@ -25,27 +25,19 @@
 
 void testInt(PriorityQueue<int> create()) {
   for (int count in [1, 5, 127, 128]) {
-    testQueue("int:$count",
-              create,
-              new List<int>.generate(count, (x) => x),
-              count);
+    testQueue(
+        "int:$count", create, new List<int>.generate(count, (x) => x), count);
   }
 }
 
 void testCustom(PriorityQueue<C> create(comparator)) {
   for (int count in [1, 5, 127, 128]) {
-    testQueue("Custom:$count/null",
-              () => create(null),
-              new List<C>.generate(count, (x) => new C(x)),
-              new C(count));
-    testQueue("Custom:$count/compare",
-              () => create(compare),
-              new List<C>.generate(count, (x) => new C(x)),
-              new C(count));
-    testQueue("Custom:$count/compareNeg",
-              () => create(compareNeg),
-              new List<C>.generate(count, (x) => new C(count - x)),
-              new C(0));
+    testQueue("Custom:$count/null", () => create(null),
+        new List<C>.generate(count, (x) => new C(x)), new C(count));
+    testQueue("Custom:$count/compare", () => create(compare),
+        new List<C>.generate(count, (x) => new C(x)), new C(count));
+    testQueue("Custom:$count/compareNeg", () => create(compareNeg),
+        new List<C>.generate(count, (x) => new C(count - x)), new C(0));
   }
 }
 
@@ -60,8 +52,12 @@
   PriorityQueue q = create();
   expect(q.isEmpty, isTrue);
   expect(q, hasLength(0));
-  expect(() { q.first; }, throwsStateError);
-  expect(() { q.removeFirst(); }, throwsStateError);
+  expect(() {
+    q.first;
+  }, throwsStateError);
+  expect(() {
+    q.removeFirst();
+  }, throwsStateError);
 
   // Tests removeFirst, first, contains, toList and toSet.
   void testElements() {
@@ -117,6 +113,7 @@
     if (mid + 1 < max) addRec(mid + 1, max);
     if (mid > min) addRec(min, mid);
   }
+
   addRec(0, elements.length);
   testElements();
 
@@ -159,7 +156,6 @@
   expect(q.isEmpty, isTrue);
 }
 
-
 // Custom class.
 // Class is comparable, comparators match normal and inverse order.
 int compare(C c1, C c2) => c1.value - c2.value;
@@ -169,7 +165,7 @@
   final int value;
   const C(this.value);
   int get hashCode => value;
-  bool operator==(Object other) => other is C && value == other.value;
+  bool operator ==(Object other) => other is C && value == other.value;
   int compareTo(C other) => value - other.value;
   String toString() => "C($value)";
 }
diff --git a/test/queue_list_test.dart b/test/queue_list_test.dart
index deee459..9e6d199 100644
--- a/test/queue_list_test.dart
+++ b/test/queue_list_test.dart
@@ -69,7 +69,8 @@
       expect(queue, equals([2, 3]));
     });
 
-    test("removes an element from the beginning of a queue with an internal "
+    test(
+        "removes an element from the beginning of a queue with an internal "
         "gap", () {
       var queue = withInternalGap();
       expect(queue.removeFirst(), equals(1));
@@ -167,7 +168,8 @@
       expect(() => queue[-1], throwsRangeError);
     });
 
-    test("throws a RangeError if the index is greater than or equal to the "
+    test(
+        "throws a RangeError if the index is greater than or equal to the "
         "length", () {
       var queue = new QueueList.from([1, 2, 3]);
       expect(() => queue[3], throwsRangeError);
@@ -202,7 +204,8 @@
       }, throwsRangeError);
     });
 
-    test("throws a RangeError if the index is greater than or equal to the "
+    test(
+        "throws a RangeError if the index is greater than or equal to the "
         "length", () {
       var queue = new QueueList.from([1, 2, 3]);
       expect(() {
@@ -271,5 +274,5 @@
 
 /// Returns a matcher that expects that a closure throws a
 /// [ConcurrentModificationError].
-final throwsConcurrentModificationError = throwsA(
-    new isInstanceOf<ConcurrentModificationError>());
+final throwsConcurrentModificationError =
+    throwsA(new isInstanceOf<ConcurrentModificationError>());
diff --git a/test/typed_wrapper/iterable_test.dart b/test/typed_wrapper/iterable_test.dart
index ff044da..b20dd27 100644
--- a/test/typed_wrapper/iterable_test.dart
+++ b/test/typed_wrapper/iterable_test.dart
@@ -13,12 +13,12 @@
     var emptyWrapper;
     var singleWrapper;
     setUp(() {
-      wrapper = DelegatingIterable.typed/*<int>*/(
-          <Object>[1, 2, 3, 4, 5].map((i) => i));
-      emptyWrapper = DelegatingIterable.typed/*<int>*/(
-          <Object>[].map((i) => i));
-      singleWrapper = DelegatingIterable.typed/*<int>*/(
-          <Object>[1].map((i) => i));
+      wrapper = DelegatingIterable
+          .typed/*<int>*/(<Object>[1, 2, 3, 4, 5].map((i) => i));
+      emptyWrapper =
+          DelegatingIterable.typed/*<int>*/(<Object>[].map((i) => i));
+      singleWrapper =
+          DelegatingIterable.typed/*<int>*/(<Object>[1].map((i) => i));
     });
 
     test("any()", () {
@@ -130,8 +130,8 @@
 
     test("reduce()", () {
       expect(wrapper.reduce((value, i) => value + i), equals(15));
-      expect(() => emptyWrapper.reduce((value, i) => value + i),
-          throwsStateError);
+      expect(
+          () => emptyWrapper.reduce((value, i) => value + i), throwsStateError);
     });
 
     test("single", () {
@@ -142,8 +142,8 @@
     test("singleWhere()", () {
       expect(() => wrapper.singleWhere((i) => i.isOdd), throwsStateError);
       expect(singleWrapper.singleWhere((i) => i.isOdd), equals(1));
-      expect(() => singleWrapper.singleWhere((i) => i.isEven),
-          throwsStateError);
+      expect(
+          () => singleWrapper.singleWhere((i) => i.isEven), throwsStateError);
     });
 
     test("skip()", () {
@@ -171,8 +171,8 @@
     test("toList()", () {
       expect(wrapper.toList(), equals([1, 2, 3, 4, 5]));
       expect(wrapper.toList(growable: false), equals([1, 2, 3, 4, 5]));
-      expect(() => wrapper.toList(growable: false).add(6),
-          throwsUnsupportedError);
+      expect(
+          () => wrapper.toList(growable: false).add(6), throwsUnsupportedError);
     });
 
     test("toSet()", () {
@@ -198,8 +198,8 @@
     setUp(() {
       wrapper = DelegatingIterable.typed/*<int>*/(
           <Object>["foo", "bar", "baz"].map((element) => element));
-      singleWrapper = DelegatingIterable.typed/*<int>*/(
-          <Object>["foo"].map((element) => element));
+      singleWrapper = DelegatingIterable
+          .typed/*<int>*/(<Object>["foo"].map((element) => element));
     });
 
     group("throws a CastError for", () {
@@ -232,7 +232,8 @@
       });
 
       test("fold()", () {
-        expect(() => wrapper.fold(null, expectAsync2((_, __) => null, count: 0)),
+        expect(
+            () => wrapper.fold(null, expectAsync2((_, __) => null, count: 0)),
             throwsCastError);
       });
 
diff --git a/test/typed_wrapper/map_test.dart b/test/typed_wrapper/map_test.dart
index 30c6426..3ebf02b 100644
--- a/test/typed_wrapper/map_test.dart
+++ b/test/typed_wrapper/map_test.dart
@@ -29,14 +29,14 @@
       expect(wrapper, equals({"foo": 5, "bar": 2, "baz": 3, "bang": 4}));
 
       wrapper["qux"] = 6;
-      expect(wrapper,
-          equals({"foo": 5, "bar": 2, "baz": 3, "bang": 4, "qux": 6}));
+      expect(
+          wrapper, equals({"foo": 5, "bar": 2, "baz": 3, "bang": 4, "qux": 6}));
     });
 
     test("addAll()", () {
       wrapper.addAll({"bar": 5, "qux": 6});
-      expect(wrapper,
-          equals({"foo": 1, "bar": 5, "baz": 3, "bang": 4, "qux": 6}));
+      expect(
+          wrapper, equals({"foo": 1, "bar": 5, "baz": 3, "bang": 4, "qux": 6}));
     });
 
     test("clear()", () {
@@ -59,8 +59,14 @@
     test("forEach()", () {
       var results = [];
       wrapper.forEach((key, value) => results.add([key, value]));
-      expect(results,
-          unorderedEquals([["foo", 1], ["bar", 2], ["baz", 3], ["bang", 4]]));
+      expect(
+          results,
+          unorderedEquals([
+            ["foo", 1],
+            ["bar", 2],
+            ["baz", 3],
+            ["bang", 4]
+          ]));
 
       emptyWrapper.forEach(expectAsync2((_, __) {}, count: 0));
     });
@@ -90,8 +96,8 @@
           equals(1));
 
       expect(wrapper.putIfAbsent("qux", () => 6), equals(6));
-      expect(wrapper,
-          equals({"foo": 1, "bar": 2, "baz": 3, "bang": 4, "qux": 6}));
+      expect(
+          wrapper, equals({"foo": 1, "bar": 2, "baz": 3, "bang": 4, "qux": 6}));
     });
 
     test("remove()", () {
@@ -108,14 +114,16 @@
     });
 
     test("toString()", () {
-      expect(wrapper.toString(), allOf([
-        startsWith("{"),
-        contains("foo: 1"),
-        contains("bar: 2"),
-        contains("baz: 3"),
-        contains("bang: 4"),
-        endsWith("}")
-      ]));
+      expect(
+          wrapper.toString(),
+          allOf([
+            startsWith("{"),
+            contains("foo: 1"),
+            contains("bar: 2"),
+            contains("baz: 3"),
+            contains("bang: 4"),
+            endsWith("}")
+          ]));
     });
   });
 
@@ -203,14 +211,16 @@
       });
 
       test("toString()", () {
-        expect(wrapper.toString(), allOf([
-          startsWith("{"),
-          contains("1: 1"),
-          contains("2: 2"),
-          contains("3: 3"),
-          contains("4: 4"),
-          endsWith("}")
-        ]));
+        expect(
+            wrapper.toString(),
+            allOf([
+              startsWith("{"),
+              contains("1: 1"),
+              contains("2: 2"),
+              contains("3: 3"),
+              contains("4: 4"),
+              endsWith("}")
+            ]));
       });
     });
   }, skip: "Re-enable this when test can run DDC (test#414).");
@@ -303,12 +313,14 @@
       });
 
       test("toString()", () {
-        expect(wrapper.toString(), allOf([
-          startsWith("{"),
-          contains("foo: bar"),
-          contains("baz: bang"),
-          endsWith("}")
-        ]));
+        expect(
+            wrapper.toString(),
+            allOf([
+              startsWith("{"),
+              contains("foo: bar"),
+              contains("baz: bang"),
+              endsWith("}")
+            ]));
       });
     });
   }, skip: "Re-enable this when test can run DDC (test#414).");
diff --git a/test/typed_wrapper/queue_test.dart b/test/typed_wrapper/queue_test.dart
index 4eb68b3..256280d 100644
--- a/test/typed_wrapper/queue_test.dart
+++ b/test/typed_wrapper/queue_test.dart
@@ -14,8 +14,8 @@
     var wrapper;
     var emptyWrapper;
     setUp(() {
-      wrapper = DelegatingQueue.typed/*<int>*/(
-          new Queue<Object>.from([1, 2, 3, 4, 5]));
+      wrapper = DelegatingQueue
+          .typed/*<int>*/(new Queue<Object>.from([1, 2, 3, 4, 5]));
       emptyWrapper = DelegatingQueue.typed/*<int>*/(new Queue<Object>());
     });
 
diff --git a/test/typed_wrapper/set_test.dart b/test/typed_wrapper/set_test.dart
index 7667442..fdbbf8e 100644
--- a/test/typed_wrapper/set_test.dart
+++ b/test/typed_wrapper/set_test.dart
@@ -11,8 +11,8 @@
   group("with valid types, forwards", () {
     var wrapper;
     setUp(() {
-      wrapper = DelegatingSet.typed/*<int>*/(
-          new Set<Object>.from([1, 2, 3, 4, 5]));
+      wrapper =
+          DelegatingSet.typed/*<int>*/(new Set<Object>.from([1, 2, 3, 4, 5]));
     });
 
     test("add()", () {
diff --git a/test/unmodifiable_collection_test.dart b/test/unmodifiable_collection_test.dart
index cdb5101..91ad8ad 100644
--- a/test/unmodifiable_collection_test.dart
+++ b/test/unmodifiable_collection_test.dart
@@ -94,8 +94,8 @@
   });
 
   test("$name - expand", () {
-    expect(wrapped.expand((x) => [x, x]),
-           equals(original.expand((x) => [x, x])));
+    expect(
+        wrapped.expand((x) => [x, x]), equals(original.expand((x) => [x, x])));
   });
 
   test("$name - first", () {
@@ -111,21 +111,25 @@
       expect(() => wrapped.firstWhere((_) => true), throws);
     } else {
       expect(wrapped.firstWhere((_) => true),
-             equals(original.firstWhere((_) => true)));
+          equals(original.firstWhere((_) => true)));
     }
     expect(() => wrapped.firstWhere((_) => false), throws);
   });
 
   test("$name - fold", () {
     expect(wrapped.fold(0, (x, y) => x + y),
-           equals(original.fold(0, (x, y) => x + y)));
+        equals(original.fold(0, (x, y) => x + y)));
   });
 
   test("$name - forEach", () {
     int wrapCtr = 0;
     int origCtr = 0;
-    wrapped.forEach((x) { wrapCtr += x; });
-    original.forEach((x) { origCtr += x; });
+    wrapped.forEach((x) {
+      wrapCtr += x;
+    });
+    original.forEach((x) {
+      origCtr += x;
+    });
     expect(wrapCtr, equals(origCtr));
   });
 
@@ -165,7 +169,7 @@
       expect(() => wrapped.lastWhere((_) => true), throws);
     } else {
       expect(wrapped.lastWhere((_) => true),
-             equals(original.lastWhere((_) => true)));
+          equals(original.lastWhere((_) => true)));
     }
     expect(() => wrapped.lastWhere((_) => false), throws);
   });
@@ -175,8 +179,7 @@
   });
 
   test("$name - map", () {
-    expect(wrapped.map((x) => "[$x]"),
-           equals(original.map((x) => "[$x]")));
+    expect(wrapped.map((x) => "[$x]"), equals(original.map((x) => "[$x]")));
   });
 
   test("$name - reduce", () {
@@ -184,7 +187,7 @@
       expect(() => wrapped.reduce((x, y) => x + y), throws);
     } else {
       expect(wrapped.reduce((x, y) => x + y),
-             equals(original.reduce((x, y) => x + y)));
+          equals(original.reduce((x, y) => x + y)));
     }
   });
 
@@ -201,7 +204,7 @@
       expect(() => wrapped.singleWhere((_) => true), throws);
     } else {
       expect(wrapped.singleWhere((_) => true),
-             equals(original.singleWhere((_) => true)));
+          equals(original.singleWhere((_) => true)));
     }
     expect(() => wrapped.singleWhere((_) => false), throws);
   });
@@ -214,11 +217,11 @@
 
   test("$name - skipWhile", () {
     expect(wrapped.skipWhile((x) => true),
-           orderedEquals(original.skipWhile((x) => true)));
+        orderedEquals(original.skipWhile((x) => true)));
     expect(wrapped.skipWhile((x) => false),
-           orderedEquals(original.skipWhile((x) => false)));
+        orderedEquals(original.skipWhile((x) => false)));
     expect(wrapped.skipWhile((x) => x != 42),
-           orderedEquals(original.skipWhile((x) => x != 42)));
+        orderedEquals(original.skipWhile((x) => x != 42)));
   });
 
   test("$name - take", () {
@@ -229,17 +232,17 @@
 
   test("$name - takeWhile", () {
     expect(wrapped.takeWhile((x) => true),
-           orderedEquals(original.takeWhile((x) => true)));
+        orderedEquals(original.takeWhile((x) => true)));
     expect(wrapped.takeWhile((x) => false),
-           orderedEquals(original.takeWhile((x) => false)));
+        orderedEquals(original.takeWhile((x) => false)));
     expect(wrapped.takeWhile((x) => x != 42),
-           orderedEquals(original.takeWhile((x) => x != 42)));
+        orderedEquals(original.takeWhile((x) => x != 42)));
   });
 
   test("$name - toList", () {
     expect(wrapped.toList(), orderedEquals(original.toList()));
     expect(wrapped.toList(growable: false),
-           orderedEquals(original.toList(growable: false)));
+        orderedEquals(original.toList(growable: false)));
   });
 
   test("$name - toSet", () {
@@ -247,12 +250,12 @@
   });
 
   test("$name - where", () {
-    expect(wrapped.where((x) => true),
-           orderedEquals(original.where((x) => true)));
+    expect(
+        wrapped.where((x) => true), orderedEquals(original.where((x) => true)));
     expect(wrapped.where((x) => false),
-           orderedEquals(original.where((x) => false)));
+        orderedEquals(original.where((x) => false)));
     expect(wrapped.where((x) => x != 42),
-           orderedEquals(original.where((x) => x != 42)));
+        orderedEquals(original.where((x) => x != 42)));
   });
 }
 
@@ -271,7 +274,9 @@
 
   test("$name - []", () {
     if (original.isEmpty) {
-      expect(() { wrapped[0]; }, throwsRangeError);
+      expect(() {
+        wrapped[0];
+      }, throwsRangeError);
     } else {
       expect(wrapped[0], equals(original[0]));
     }
@@ -289,17 +294,16 @@
     int len = original.length;
     expect(wrapped.getRange(0, len), equals(original.getRange(0, len)));
     expect(wrapped.getRange(len ~/ 2, len),
-           equals(original.getRange(len ~/ 2, len)));
-    expect(wrapped.getRange(0, len ~/ 2),
-           equals(original.getRange(0, len ~/ 2)));
+        equals(original.getRange(len ~/ 2, len)));
+    expect(
+        wrapped.getRange(0, len ~/ 2), equals(original.getRange(0, len ~/ 2)));
   });
 
   test("$name - sublist", () {
     int len = original.length;
     expect(wrapped.sublist(0), equals(original.sublist(0)));
     expect(wrapped.sublist(len ~/ 2), equals(original.sublist(len ~/ 2)));
-    expect(wrapped.sublist(0, len ~/ 2),
-           equals(original.sublist(0, len ~/ 2)));
+    expect(wrapped.sublist(0, len ~/ 2), equals(original.sublist(0, len ~/ 2)));
   });
 
   test("$name - asMap", () {
@@ -318,21 +322,25 @@
     });
   }
 
-  testThrows("$name - []= throws", () { wrapped[0] = 42; });
+  testThrows("$name - []= throws", () {
+    wrapped[0] = 42;
+  });
 
-  testThrows("$name - sort throws", () { wrapped.sort(); });
+  testThrows("$name - sort throws", () {
+    wrapped.sort();
+  });
 
   testThrows("$name - fillRange throws", () {
     wrapped.fillRange(0, wrapped.length, 42);
   });
 
   testThrows("$name - setRange throws", () {
-      wrapped.setRange(0, wrapped.length,
-                    new Iterable.generate(wrapped.length, (i) => i));
+    wrapped.setRange(
+        0, wrapped.length, new Iterable.generate(wrapped.length, (i) => i));
   });
 
   testThrows("$name - setAll throws", () {
-      wrapped.setAll(0, new Iterable.generate(wrapped.length, (i) => i));
+    wrapped.setAll(0, new Iterable.generate(wrapped.length, (i) => i));
   });
 }
 
@@ -346,7 +354,9 @@
       expect(original[0], equals(originalFirst + 1));
       original[0] = originalFirst;
     } else {
-      expect(() { wrapped[0] = 42; }, throws);
+      expect(() {
+        wrapped[0] = 42;
+      }, throws);
     }
   });
 
@@ -459,21 +469,21 @@
     expect(wrapped.intersection(new Set()), isEmpty);
     expect(wrapped.intersection(copy), unorderedEquals(original));
     expect(wrapped.intersection(new Set.from([42])),
-            new Set.from(original.contains(42) ? [42] : []));
+        new Set.from(original.contains(42) ? [42] : []));
   });
 
   test("$name - union", () {
     expect(wrapped.union(new Set()), unorderedEquals(original));
     expect(wrapped.union(copy), unorderedEquals(original));
     expect(wrapped.union(new Set.from([42])),
-           equals(original.union(new Set.from([42]))));
+        equals(original.union(new Set.from([42]))));
   });
 
   test("$name - difference", () {
     expect(wrapped.difference(new Set()), unorderedEquals(original));
     expect(wrapped.difference(copy), isEmpty);
     expect(wrapped.difference(new Set.from([42])),
-           equals(original.difference(new Set.from([42]))));
+        equals(original.difference(new Set.from([42]))));
   });
 }
 
@@ -560,8 +570,12 @@
   test("$name forEach", () {
     int origCnt = 0;
     int wrapCnt = 0;
-    wrapped.forEach((k, v) { wrapCnt += 1 << k + 3 * v; });
-    original.forEach((k, v) { origCnt += 1 << k + 3 * v; });
+    wrapped.forEach((k, v) {
+      wrapCnt += 1 << k + 3 * v;
+    });
+    original.forEach((k, v) {
+      origCnt += 1 << k + 3 * v;
+    });
     expect(wrapCnt, equals(origCnt));
   });
 
@@ -585,27 +599,27 @@
     });
   }
 
- testThrows("$name operator[]= throws", () {
-   wrapped[0] = 42;
- });
+  testThrows("$name operator[]= throws", () {
+    wrapped[0] = 42;
+  });
 
- testThrows("$name putIfAbsent throws", () {
-   wrapped.putIfAbsent(0, () => 42);
- });
+  testThrows("$name putIfAbsent throws", () {
+    wrapped.putIfAbsent(0, () => 42);
+  });
 
- testThrows("$name addAll throws", () {
-   wrapped.addAll(new Map()..[42] = 42);
- });
+  testThrows("$name addAll throws", () {
+    wrapped.addAll(new Map()..[42] = 42);
+  });
 
- testThrows("$name addAll empty throws", () {
-   wrapped.addAll(new Map());
- });
+  testThrows("$name addAll empty throws", () {
+    wrapped.addAll(new Map());
+  });
 
- testThrows("$name remove throws", () {
-   wrapped.remove(0);
- });
+  testThrows("$name remove throws", () {
+    wrapped.remove(0);
+  });
 
- testThrows("$name clear throws", () {
-   wrapped.clear();
- });
+  testThrows("$name clear throws", () {
+    wrapped.clear();
+  });
 }
diff --git a/test/wrapper_test.dart b/test/wrapper_test.dart
index e488945..df26c87 100644
--- a/test/wrapper_test.dart
+++ b/test/wrapper_test.dart
@@ -33,14 +33,14 @@
   var equals;
 
   noSuchMethod(Invocation m) => new _Equals(equals = getWrappedObject((m2) {
-    testInvocations(m, m2);
-  }));
+        testInvocations(m, m2);
+      }));
 
   // dartanalyzer complains if this method is named `toString()`, since, if it
   // truly overrides Object's `toString()`, it should return a String.
   asString() => new _Equals(equals = getWrappedObject((m2) {
-    testInvocations(TO_STRING_INVOCATION, m2);
-  }));
+        testInvocations(TO_STRING_INVOCATION, m2);
+      }));
 }
 
 // An object with a field called "equals", only introduced into the
@@ -58,10 +58,8 @@
   final List positionalArguments;
   final Map<Symbol, dynamic> namedArguments;
   final int _type;
-  const SyntheticInvocation(this.memberName,
-                            this.positionalArguments,
-                            this.namedArguments,
-                            this._type);
+  const SyntheticInvocation(this.memberName, this.positionalArguments,
+      this.namedArguments, this._type);
   bool get isMethod => _type == METHOD;
 
   bool get isGetter => _type == GETTER;
@@ -79,7 +77,7 @@
 }
 
 const TO_STRING_INVOCATION = const SyntheticInvocation(
-  #toString, const[], const{}, SyntheticInvocation.METHOD);
+    #toString, const [], const {}, SyntheticInvocation.METHOD);
 
 // LikeNSM, but has types Iterable, Set and List to allow it as
 // argument to DelegatingIterable/Set/List.
@@ -148,8 +146,10 @@
     // expectation (which doesn't have the interface implemented or
     // its default values).
     expect.firstWhere(func1, orElse: null).equals.firstWhere(func1);
-    expect.firstWhere(func1, orElse: func0).equals.
-           firstWhere(func1, orElse: func0);
+    expect
+        .firstWhere(func1, orElse: func0)
+        .equals
+        .firstWhere(func1, orElse: func0);
     expect.fold(null, func2).equals.fold(null, func2);
     expect.forEach(func1).equals.forEach(func1);
     expect.isEmpty.equals.isEmpty;
@@ -159,8 +159,10 @@
     expect.join("X").equals.join("X");
     expect.last.equals.last;
     expect.lastWhere(func1, orElse: null).equals.lastWhere(func1);
-    expect.lastWhere(func1, orElse: func0).equals.
-           lastWhere(func1, orElse: func0);
+    expect
+        .lastWhere(func1, orElse: func0)
+        .equals
+        .lastWhere(func1, orElse: func0);
     expect.length.equals.length;
     expect.map(func1).equals.map(func1);
     expect.reduce(func2).equals.reduce(func2);
@@ -336,17 +338,17 @@
 
       test(".lastWhere", () {
         expect(set.lastWhere((element) => element is String), equals("bar"));
-        expect(set.lastWhere((element) => element.startsWith("f")),
-            equals("foo"));
-        expect(() => set.lastWhere((element) => element is int),
-            throwsStateError);
+        expect(
+            set.lastWhere((element) => element.startsWith("f")), equals("foo"));
+        expect(
+            () => set.lastWhere((element) => element is int), throwsStateError);
         expect(set.lastWhere((element) => element is int, orElse: () => "baz"),
             equals("baz"));
       });
 
       test(".map", () {
-        expect(set.map((element) => element.substring(1)),
-            equals(["oo", "ar"]));
+        expect(
+            set.map((element) => element.substring(1)), equals(["oo", "ar"]));
       });
 
       test(".reduce", () {
@@ -357,8 +359,7 @@
       test(".singleWhere", () {
         expect(() => set.singleWhere((element) => element == "baz"),
             throwsStateError);
-        expect(set.singleWhere((element) => element == "foo"),
-            "foo");
+        expect(set.singleWhere((element) => element == "foo"), "foo");
         expect(() => set.singleWhere((element) => element is String),
             throwsStateError);
       });
@@ -374,8 +375,7 @@
             equals(["bar"]));
         expect(set.skipWhile((element) => element.startsWith("z")),
             equals(["foo", "bar"]));
-        expect(set.skipWhile((element) => element is String),
-            equals([]));
+        expect(set.skipWhile((element) => element is String), equals([]));
       });
 
       test(".take", () {
@@ -387,8 +387,7 @@
       test(".takeWhile", () {
         expect(set.takeWhile((element) => element.startsWith("f")),
             equals(["foo"]));
-        expect(set.takeWhile((element) => element.startsWith("z")),
-            equals([]));
+        expect(set.takeWhile((element) => element.startsWith("z")), equals([]));
         expect(set.takeWhile((element) => element is String),
             equals(["foo", "bar"]));
       });
@@ -405,11 +404,11 @@
       });
 
       test(".where", () {
-        expect(set.where((element) => element.startsWith("f")),
-            equals(["foo"]));
+        expect(
+            set.where((element) => element.startsWith("f")), equals(["foo"]));
         expect(set.where((element) => element.startsWith("z")), equals([]));
-        expect(set.where((element) => element is String),
-            equals(["foo", "bar"]));
+        expect(
+            set.where((element) => element is String), equals(["foo", "bar"]));
       });
 
       test(".containsAll", () {
@@ -529,8 +528,8 @@
 
     setUp(() {
       map = new Map<String, String>();
-      set = new MapValueSet<String, String>(map,
-          (string) => string.substring(0, 1));
+      set = new MapValueSet<String, String>(
+          map, (string) => string.substring(0, 1));
     });
 
     testTwoElementSet(() {
@@ -641,8 +640,8 @@
           equals: (value1, value2) =>
               value1.toLowerCase() == value2.toLowerCase(),
           hashCode: (value) => value.toLowerCase().hashCode);
-      set = new MapValueSet<String, String>(map,
-          (string) => string.substring(0, 1));
+      set = new MapValueSet<String, String>(
+          map, (string) => string.substring(0, 1));
 
       map["f"] = "foo";
       map["B"] = "bar";