Format all tests.

tests/corelib_strong/map_test.dart

 // Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library map_test;
+
 import "package:expect/expect.dart";
 import 'dart:collection';
 import 'dart:convert' show JSON;
 
-Map newJsonMap()
-    => JSON.decode('{}');
-Map newJsonMapCustomReviver()
-    => JSON.decode('{}', reviver: (key, value) => value);
+Map newJsonMap() => JSON.decode('{}');
+Map newJsonMapCustomReviver() =>
+    JSON.decode('{}', reviver: (key, value) => value);
 
 void main() {
   test(new HashMap());
   test(new LinkedHashMap());
   test(new SplayTreeMap());
   test(new SplayTreeMap(Comparable.compare));
   test(new MapView(new HashMap()));
   test(new MapView(new SplayTreeMap()));
   test(new MapBaseMap());
   test(new MapMixinMap());
@@ skipping 41 matching lines @@
   testNaNKeys(new MapBaseMap<num, String>());
   testNaNKeys(new MapMixinMap<num, String>());
   testNaNKeys(newJsonMap());
   testNaNKeys(newJsonMapCustomReviver());
   // Identity maps fail the NaN-keys tests because the test assumes that
   // NaN is not equal to NaN.
 
   testIdentityMap(new Map.identity());
   testIdentityMap(new HashMap.identity());
   testIdentityMap(new LinkedHashMap.identity());
-  testIdentityMap(new HashMap(equals: identical,
-                              hashCode: identityHashCode));
-  testIdentityMap(new LinkedHashMap(equals: identical,
-                                    hashCode: identityHashCode));
-  testIdentityMap(new HashMap(equals: (x, y) => identical(x, y),
-                              hashCode: (x) => identityHashCode(x)));
-  testIdentityMap(new LinkedHashMap(equals: (x, y) => identical(x, y),
-                                    hashCode: (x) => identityHashCode(x)));
+  testIdentityMap(new HashMap(equals: identical, hashCode: identityHashCode));
+  testIdentityMap(
+      new LinkedHashMap(equals: identical, hashCode: identityHashCode));
+  testIdentityMap(new HashMap(
+      equals: (x, y) => identical(x, y), hashCode: (x) => identityHashCode(x)));
+  testIdentityMap(new LinkedHashMap(
+      equals: (x, y) => identical(x, y), hashCode: (x) => identityHashCode(x)));
 
-  testCustomMap(new HashMap(equals: myEquals, hashCode: myHashCode,
-                            isValidKey: (v) => v is Customer));
-  testCustomMap(new LinkedHashMap(equals: myEquals, hashCode: myHashCode,
-                                  isValidKey: (v) => v is Customer));
-  testCustomMap(new HashMap<Customer,dynamic>(equals: myEquals,
-                                              hashCode: myHashCode));
+  testCustomMap(new HashMap(
+      equals: myEquals,
+      hashCode: myHashCode,
+      isValidKey: (v) => v is Customer));
+  testCustomMap(new LinkedHashMap(
+      equals: myEquals,
+      hashCode: myHashCode,
+      isValidKey: (v) => v is Customer));
+  testCustomMap(
+      new HashMap<Customer, dynamic>(equals: myEquals, hashCode: myHashCode));
 
-  testCustomMap(new LinkedHashMap<Customer,dynamic>(equals: myEquals,
-                                                    hashCode: myHashCode));
+  testCustomMap(new LinkedHashMap<Customer, dynamic>(
+      equals: myEquals, hashCode: myHashCode));
 
   testIterationOrder(new LinkedHashMap());
   testIterationOrder(new LinkedHashMap.identity());
   testIterationOrder(newJsonMap());
   testIterationOrder(newJsonMapCustomReviver());
 
   testOtherKeys(new SplayTreeMap<int, int>());
-  testOtherKeys(new SplayTreeMap<int, int>((int a, int b) => a - b,
-                                           (v) => v is int));
-  testOtherKeys(new SplayTreeMap((int a, int b) => a - b,
-                                 (v) => v is int));
+  testOtherKeys(
+      new SplayTreeMap<int, int>((int a, int b) => a - b, (v) => v is int));
+  testOtherKeys(new SplayTreeMap((int a, int b) => a - b, (v) => v is int));
   testOtherKeys(new HashMap<int, int>());
   testOtherKeys(new HashMap<int, int>.identity());
-  testOtherKeys(new HashMap<int, int>(hashCode: (v) => v.hashCode,
-                                      isValidKey: (v) => v is int));
-  testOtherKeys(new HashMap(equals: (int x, int y) => x == y,
-                            hashCode: (int v) => v.hashCode,
-                            isValidKey: (v) => v is int));
+  testOtherKeys(new HashMap<int, int>(
+      hashCode: (v) => v.hashCode, isValidKey: (v) => v is int));
+  testOtherKeys(new HashMap(
+      equals: (int x, int y) => x == y,
+      hashCode: (int v) => v.hashCode,
+      isValidKey: (v) => v is int));
   testOtherKeys(new LinkedHashMap<int, int>());
   testOtherKeys(new LinkedHashMap<int, int>.identity());
-  testOtherKeys(new LinkedHashMap<int, int>(hashCode: (v) => v.hashCode,
-                                       isValidKey: (v) => v is int));
-  testOtherKeys(new LinkedHashMap(equals: (int x, int y) => x == y,
-                                  hashCode: (int v) => v.hashCode,
-                                  isValidKey: (v) => v is int));
+  testOtherKeys(new LinkedHashMap<int, int>(
+      hashCode: (v) => v.hashCode, isValidKey: (v) => v is int));
+  testOtherKeys(new LinkedHashMap(
+      equals: (int x, int y) => x == y,
+      hashCode: (int v) => v.hashCode,
+      isValidKey: (v) => v is int));
   testOtherKeys(new MapBaseMap<int, int>());
   testOtherKeys(new MapMixinMap<int, int>());
   testOtherKeys(newJsonMap());
   testOtherKeys(newJsonMapCustomReviver());
 
-  testUnmodifiableMap(const {1 : 37});
-  testUnmodifiableMap(new UnmodifiableMapView({1 : 37}));
+  testUnmodifiableMap(const {1: 37});
+  testUnmodifiableMap(new UnmodifiableMapView({1: 37}));
   testUnmodifiableMap(new UnmodifiableMapBaseMap([1, 37]));
 
   testFrom();
 }
 
-
 void test(Map map) {
   testDeletedElement(map);
   testMap(map, 1, 2, 3, 4, 5, 6, 7, 8);
   map.clear();
-  testMap(map, "value1", "value2", "value3", "value4", "value5",
-          "value6", "value7", "value8");
+  testMap(map, "value1", "value2", "value3", "value4", "value5", "value6",
+      "value7", "value8");
 }
 
 void testLinkedHashMap() {
   LinkedHashMap map = new LinkedHashMap();
   Expect.equals(false, map.containsKey(1));
   map[1] = 1;
   map[1] = 2;
   testLength(1, map);
 }
 
@@ skipping 96 matching lines @@
   testLength(2, map);
 
   Expect.equals(true, map.containsKey(key1));
   Expect.equals(true, map.containsValue(value1));
 
   // Test Map.forEach.
   Map otherMap = new Map();
   void testForEachMap(key, value) {
     otherMap[key] = value;
   }
+
   map.forEach(testForEachMap);
   Expect.equals(true, otherMap.containsKey(key1));
   Expect.equals(true, otherMap.containsKey(key2));
   Expect.equals(true, otherMap.containsValue(value1));
   Expect.equals(true, otherMap.containsValue(value2));
   Expect.equals(2, otherMap.length);
 
   otherMap.clear();
   Expect.equals(0, otherMap.length);
 
   // Test Collection.keys.
   void testForEachCollection(value) {
     otherMap[value] = value;
   }
+
   Iterable keys = map.keys;
   keys.forEach(testForEachCollection);
   Expect.equals(true, otherMap.containsKey(key1));
   Expect.equals(true, otherMap.containsKey(key2));
   Expect.equals(true, otherMap.containsValue(key1));
   Expect.equals(true, otherMap.containsValue(key2));
   Expect.equals(true, !otherMap.containsKey(value1));
   Expect.equals(true, !otherMap.containsKey(value2));
   Expect.equals(true, !otherMap.containsValue(value1));
   Expect.equals(true, !otherMap.containsValue(value2));
@@ skipping 15 matching lines @@
   Expect.equals(2, otherMap.length);
   otherMap.clear();
   Expect.equals(0, otherMap.length);
 
   // Test Map.putIfAbsent.
   map.clear();
   Expect.equals(false, map.containsKey(key1));
   map.putIfAbsent(key1, () => 10);
   Expect.equals(true, map.containsKey(key1));
   Expect.equals(10, map[key1]);
-  Expect.equals(10,
-      map.putIfAbsent(key1, () => 11));
+  Expect.equals(10, map.putIfAbsent(key1, () => 11));
 
   // Test Map.addAll.
   map.clear();
   otherMap.clear();
   otherMap[99] = 1;
   otherMap[50] = 50;
   otherMap[1] = 99;
   map.addAll(otherMap);
   Expect.equals(3, map.length);
   Expect.equals(1, map[99]);
@@ skipping 29 matching lines @@
   for (int i = 0; i < 100; i++) {
     map[1] = 2;
     testLength(1, map);
     map.remove(1);
     testLength(0, map);
   }
   testLength(0, map);
 }
 
 void testMapLiteral() {
-  Map m = {"a": 1, "b" : 2, "c": 3 };
+  Map m = {"a": 1, "b": 2, "c": 3};
   Expect.equals(3, m.length);
   int sum = 0;
   m.forEach((a, b) {
     sum += b;
   });
   Expect.equals(6, sum);
 
   List values = m.keys.toList();
   Expect.equals(3, values.length);
   String first = values[0];
   String second = values[1];
   String third = values[2];
   String all = "${first}${second}${third}";
   Expect.equals(3, all.length);
   Expect.equals(true, all.contains("a", 0));
   Expect.equals(true, all.contains("b", 0));
   Expect.equals(true, all.contains("c", 0));
 }
 
 void testNullValue() {
-  Map m = {"a": 1, "b" : null, "c": 3 };
+  Map m = {"a": 1, "b": null, "c": 3};
 
   Expect.equals(null, m["b"]);
   Expect.equals(true, m.containsKey("b"));
   Expect.equals(3, m.length);
 
   m["a"] = null;
   m["c"] = null;
   Expect.equals(null, m["a"]);
   Expect.equals(true, m.containsKey("a"));
   Expect.equals(null, m["c"]);
@@ skipping 22 matching lines @@
 
     // Ensure that "containsKey", "containsValue" and "remove"
     // accepts any object.
     for (var object in [true, null, new Object()]) {
       Expect.isFalse(map.containsKey(object));
       Expect.isFalse(map.containsValue(object));
       Expect.isNull(map.remove(object));
       Expect.isNull(map[object]);
     }
   }
+
   testMap(new HashMap<int, String>());
   testMap(new LinkedHashMap<int, String>());
   testMap(new SplayTreeMap<int, String>());
   testMap(new SplayTreeMap<int, String>(Comparable.compare));
   testMap(new SplayTreeMap<int, String>((int a, int b) => a.compareTo(b)));
   testMap(new HashMap<num, String>());
   testMap(new LinkedHashMap<num, String>());
   testMap(new SplayTreeMap<num, String>());
   testMap(new SplayTreeMap<num, String>(Comparable.compare));
   testMap(new SplayTreeMap<num, String>((num a, num b) => a.compareTo(b)));
 }
 
 void testWeirdStringKeys(Map map) {
   // Test weird keys.
   var weirdKeys = const [
-      'hasOwnProperty',
-      'constructor',
-      'toLocaleString',
-      'propertyIsEnumerable',
-      '__defineGetter__',
-      '__defineSetter__',
-      '__lookupGetter__',
-      '__lookupSetter__',
-      'isPrototypeOf',
-      'toString',
-      'valueOf',
-      '__proto__',
-      '__count__',
-      '__parent__',
-      ''];
+    'hasOwnProperty',
+    'constructor',
+    'toLocaleString',
+    'propertyIsEnumerable',
+    '__defineGetter__',
+    '__defineSetter__',
+    '__lookupGetter__',
+    '__lookupSetter__',
+    'isPrototypeOf',
+    'toString',
+    'valueOf',
+    '__proto__',
+    '__count__',
+    '__parent__',
+    ''
+  ];
   Expect.isTrue(map.isEmpty);
   for (var key in weirdKeys) {
     Expect.isFalse(map.containsKey(key));
     Expect.equals(null, map[key]);
     var value = 'value:$key';
     map[key] = value;
     Expect.isTrue(map.containsKey(key));
     Expect.equals(value, map[key]);
     Expect.equals(value, map.remove(key));
     Expect.isFalse(map.containsKey(key));
     Expect.equals(null, map[key]);
   }
   Expect.isTrue(map.isEmpty);
-
 }
 
 void testNumericKeys(Map map) {
   var numericKeys = const [
-      double.INFINITY,
-      double.NEGATIVE_INFINITY,
-      0,
-      0.0,
-      -0.0 ];
+    double.INFINITY,
+    double.NEGATIVE_INFINITY,
+    0,
+    0.0,
+    -0.0
+  ];
 
   Expect.isTrue(map.isEmpty);
   for (var key in numericKeys) {
     Expect.isFalse(map.containsKey(key));
     Expect.equals(null, map[key]);
     var value = 'value:$key';
     map[key] = value;
     Expect.isTrue(map.containsKey(key));
     Expect.equals(value, map[key]);
     Expect.equals(value, map.remove(key));
@@ skipping 48 matching lines @@
   ifNotEmpty(map.values.isNotEmpty);
   // Test key/value iterators match their isEmpty/isNotEmpty.
   ifNotEmpty(map.keys.iterator.moveNext());
   ifNotEmpty(map.values.iterator.moveNext());
   if (length == 0) {
     for (var k in map.keys) Expect.fail("contains key when iterating: $k");
     for (var v in map.values) Expect.fail("contains values when iterating: $v");
   }
 }
 
-
 testIdentityMap(Map map) {
   Expect.isTrue(map.isEmpty);
 
   var nan = double.NAN;
   // TODO(11551): Remove guard when dart2js makes identical(NaN, NaN) true.
   if (identical(nan, nan)) {
     map[nan] = 42;
     testLength(1, map);
     Expect.isTrue(map.containsKey(nan));
     Expect.equals(42, map[nan]);
     map[nan] = 37;
     testLength(1, map);
     Expect.equals(37, map[nan]);
     Expect.equals(37, map.remove(nan));
     testLength(0, map);
   }
 
   Vampire v1 = const Vampire(1);
   Vampire v2 = const Vampire(2);
   Expect.isFalse(v1 == v1);
   Expect.isFalse(v2 == v2);
-  Expect.isTrue(v2 == v1);  // Snob!
+  Expect.isTrue(v2 == v1); // Snob!
 
   map[v1] = 1;
   map[v2] = 2;
   testLength(2, map);
 
   Expect.isTrue(map.containsKey(v1));
   Expect.isTrue(map.containsKey(v2));
 
   Expect.equals(1, map[v1]);
   Expect.equals(2, map[v2]);
@@ skipping 92 matching lines @@
   // Even if hashcode of m3 changed, it can still be found.
   Expect.equals(1, map[m1]);
   Expect.equals(3, map[m3]);
 }
 
 /** Class of objects that are equal if they hold the same id. */
 class Equalizer {
   int id;
   Equalizer(this.id);
   int get hashCode => id;
-  bool operator==(Object other) =>
+  bool operator ==(Object other) =>
       other is Equalizer && id == (other as Equalizer).id;
 }
 
 /**
  * Objects that are not reflexive.
  *
  * They think they are better than their equals.
  */
 class Vampire {
   final int generation;
   const Vampire(this.generation);
 
   int get hashCode => generation;
 
   // The double-fang operator falsely claims that a vampire is equal to
   // any of its sire's generation.
-  bool operator==(Object other) =>
+  bool operator ==(Object other) =>
       other is Vampire && generation - 1 == (other as Vampire).generation;
 }
 
 void testCustomMap(Map map) {
   testLength(0, map);
   var c11 = const Customer(1, 1);
   var c12 = const Customer(1, 2);
   var c21 = const Customer(2, 1);
   var c22 = const Customer(2, 2);
   // Sanity.
@@ skipping 53 matching lines @@
   testLength(0, map);
 }
 
 void testUnmodifiableMap(Map map) {
   Expect.isTrue(map.containsKey(1));
   testLength(1, map);
   Expect.equals(1, map.keys.first);
   Expect.equals(37, map.values.first);
 
   Expect.throws(map.clear);
-  Expect.throws(() { map.remove(1); });
-  Expect.throws(() { map[2] = 42; });
-  Expect.throws(() { map.addAll({2 : 42}); });
+  Expect.throws(() {
+    map.remove(1);
+  });
+  Expect.throws(() {
+    map[2] = 42;
+  });
+  Expect.throws(() {
+    map.addAll({2: 42});
+  });
 }
 
 class Customer {
   final int id;
   final int secondId;
   const Customer(this.id, this.secondId);
   int get hashCode => id;
-  bool operator==(Object other) {
+  bool operator ==(Object other) {
     if (other is! Customer) return false;
     Customer otherCustomer = other;
     return id == otherCustomer.id;
   }
 }
 
 int myHashCode(Customer c) => c.secondId;
 bool myEquals(Customer a, Customer b) => a.secondId == b.secondId;
 
 void testIterationOrder(Map map) {
@@ skipping 17 matching lines @@
   Expect.isNull(map.remove("not an int"));
   Expect.isNull(map.remove(1.5));
   Expect.isNull(map["not an int"]);
   Expect.isNull(map[1.5]);
 }
 
 class Mutable {
   int id;
   Mutable(this.id);
   int get hashCode => id;
-  bool operator==(other) => other is Mutable && other.id == id;
+  bool operator ==(other) => other is Mutable && other.id == id;
 }
 
-
 // Slow implementation of Map based on MapBase.
 abstract class MapBaseOperations<K, V> {
   final List _keys = <K>[];
   final List _values = <V>[];
   int _modCount = 0;
 
-  V operator[](Object key) {
+  V operator [](Object key) {
     int index = _keys.indexOf(key);
     if (index < 0) return null;
     return _values[index];
   }
 
   Iterable<K> get keys => new TestKeyIterable<K>(this);
 
-  void operator[]=(K key, V value) {
+  void operator []=(K key, V value) {
     int index = _keys.indexOf(key);
     if (index >= 0) {
       _values[index] = value;
     } else {
       _modCount++;
       _keys.add(key);
       _values.add(value);
     }
   }
 
@@ skipping 30 matching lines @@
   TestKeyIterable(this._map);
   int get length => _map._keys.length;
   Iterator<K> get iterator => new TestKeyIterator<K>(_map);
 }
 
 class TestKeyIterator<K> implements Iterator<K> {
   final _map;
   final int _modCount;
   int _index = 0;
   var _current;
-  TestKeyIterator(map) : _map = map, _modCount = map._modCount;
+  TestKeyIterator(map)
+      : _map = map,
+        _modCount = map._modCount;
   bool moveNext() {
     if (_modCount != _map._modCount) {
       throw new ConcurrentModificationError(_map);
     }
     if (_index == _map._keys.length) {
       _current = null;
       return false;
     }
     _current = _map._keys[_index++];
     return true;
   }
+
   K get current => _current;
 }
 
 // Slow implementation of Map based on MapBase.
 class UnmodifiableMapBaseMap<K, V> extends UnmodifiableMapBase<K, V> {
   final List _keys = <K>[];
   final List _values = <V>[];
   UnmodifiableMapBaseMap(List pairs) {
     for (int i = 0; i < pairs.length; i += 2) {
       _keys.add(pairs[i]);
       _values.add(pairs[i + 1]);
     }
   }
 
   int get _modCount => 0;
 
-  V operator[](K key) {
+  V operator [](K key) {
     int index = _keys.indexOf(key);
     if (index < 0) return null;
     return _values[index];
   }
 
   Iterable<K> get keys => _keys.skip(0);
 }
 
 abstract class Super implements Comparable {}
+
 abstract class Interface implements Comparable {}
+
 class Sub extends Super implements Interface, Comparable {
   int compareTo(Sub other) => 0;
   int get hashCode => 0;
-  bool operator==(other) => other is Sub;
+  bool operator ==(other) => other is Sub;
 }
 
 expectMap(Map expect, Map actual) {
   Expect.equals(expect.length, actual.length, "length");
   for (var key in expect.keys) {
     Expect.isTrue(actual.containsKey(key), "containsKey $key");
     Expect.equals(expect[key], actual[key]);
   }
 }
 
 void testFrom() {
   // Check contents.
-  for (var map in [{}, {1: 1}, {1: 2, 3: 4, 5: 6, 7: 8}]) {
+  for (var map in [
+    {},
+    {1: 1},
+    {1: 2, 3: 4, 5: 6, 7: 8}
+  ]) {
     expectMap(map, new Map.from(map));
     expectMap(map, new HashMap.from(map));
     expectMap(map, new LinkedHashMap.from(map));
     expectMap(map, new SplayTreeMap.from(map));
   }
   // Test type combinations allowed.
-  Map<int,int> intMap = <int, int>{1: 2, 3: 4};
-  Map<num,num> numMap = <num, num>{1: 2, 3: 4};
+  Map<int, int> intMap = <int, int>{1: 2, 3: 4};
+  Map<num, num> numMap = <num, num>{1: 2, 3: 4};
   expectMap(intMap, new Map<int, int>.from(numMap));
   expectMap(intMap, new Map<num, num>.from(intMap));
   expectMap(intMap, new HashMap<int, int>.from(numMap));
   expectMap(intMap, new HashMap<num, num>.from(intMap));
   expectMap(intMap, new LinkedHashMap<int, int>.from(numMap));
   expectMap(intMap, new LinkedHashMap<num, num>.from(intMap));
   expectMap(intMap, new SplayTreeMap<int, int>.from(numMap));
   expectMap(intMap, new SplayTreeMap<num, num>.from(intMap));
 
   var sub = new Sub();
   Map<Super, Super> superMap = <Super, Super>{sub: sub};
   Map<Interface, Interface> interfaceMap = <Interface, Interface>{sub: sub};
   expectMap(superMap, new Map<Super, Super>.from(interfaceMap));
   expectMap(superMap, new Map<Interface, Interface>.from(superMap));
   expectMap(superMap, new HashMap<Super, Super>.from(interfaceMap));
   expectMap(superMap, new HashMap<Interface, Interface>.from(superMap));
   expectMap(superMap, new LinkedHashMap<Super, Super>.from(interfaceMap));
   expectMap(superMap, new LinkedHashMap<Interface, Interface>.from(superMap));
   expectMap(superMap, new SplayTreeMap<Super, Super>.from(interfaceMap));
   expectMap(superMap, new SplayTreeMap<Interface, Interface>.from(superMap));
 }