Migrated test block 16 to Dart 2.0.

tests/corelib_2/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);
 
 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());
-  test(newJsonMap());
-  test(newJsonMapCustomReviver());
+  test(newJsonMap(), useIntegerKeys: false);
+  test(newJsonMapCustomReviver(), useIntegerKeys: false);
   testLinkedHashMap();
   testMapLiteral();
   testNullValue();
   testTypes();
 
   testWeirdStringKeys(new Map());
   testWeirdStringKeys(new Map<String, String>());
   testWeirdStringKeys(new HashMap());
   testWeirdStringKeys(new HashMap<String, String>());
   testWeirdStringKeys(new LinkedHashMap());
@@ skipping 10 matching lines @@
   testNumericKeys(new HashMap());
   testNumericKeys(new HashMap<num, String>());
   testNumericKeys(new HashMap.identity());
   testNumericKeys(new HashMap<num, String>.identity());
   testNumericKeys(new LinkedHashMap());
   testNumericKeys(new LinkedHashMap<num, String>());
   testNumericKeys(new LinkedHashMap.identity());
   testNumericKeys(new LinkedHashMap<num, String>.identity());
   testNumericKeys(new MapBaseMap<num, String>());
   testNumericKeys(new MapMixinMap<num, String>());
-  testNumericKeys(newJsonMap());
-  testNumericKeys(newJsonMapCustomReviver());
 
   testNaNKeys(new Map());
   testNaNKeys(new Map<num, String>());
   testNaNKeys(new HashMap());
   testNaNKeys(new HashMap<num, String>());
   testNaNKeys(new LinkedHashMap());
   testNaNKeys(new LinkedHashMap<num, String>());
   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(
@@ skipping 35 matching lines @@
   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 MapBaseMap<int, int>());
   testOtherKeys(new MapMixinMap<int, int>());
-  testOtherKeys(newJsonMap());
-  testOtherKeys(newJsonMapCustomReviver());
 
   testUnmodifiableMap(const {1: 37});
   testUnmodifiableMap(new UnmodifiableMapView({1: 37}));
   testUnmodifiableMap(new UnmodifiableMapBaseMap([1, 37]));
 
   testFrom();
 }
 
-void test(Map map) {
+void test(Map map, {bool useIntegerKeys = true}) {
   testDeletedElement(map);
-  testMap(map, 1, 2, 3, 4, 5, 6, 7, 8);
+  if (useIntegerKeys) {
+    testMap(map, 1, 2, 3, 4, 5, 6, 7, 8);
+  }
   map.clear();
   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;
@@ skipping 155 matching lines @@
   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));
 
   // Test Map.addAll.
   map.clear();
   otherMap.clear();
-  otherMap[99] = 1;
-  otherMap[50] = 50;
-  otherMap[1] = 99;
+  otherMap['99'] = 1;
+  otherMap['50'] = 50;
+  otherMap['1'] = 99;
   map.addAll(otherMap);
   Expect.equals(3, map.length);
-  Expect.equals(1, map[99]);
-  Expect.equals(50, map[50]);
-  Expect.equals(99, map[1]);
-  otherMap[50] = 42;
+  Expect.equals(1, map['99']);
+  Expect.equals(50, map['50']);
+  Expect.equals(99, map['1']);
+  otherMap['50'] = 42;
   map.addAll(new HashMap.from(otherMap));
   Expect.equals(3, map.length);
-  Expect.equals(1, map[99]);
-  Expect.equals(42, map[50]);
-  Expect.equals(99, map[1]);
-  otherMap[99] = 7;
+  Expect.equals(1, map['99']);
+  Expect.equals(42, map['50']);
+  Expect.equals(99, map['1']);
+  otherMap['99'] = 7;
   map.addAll(new SplayTreeMap.from(otherMap));
   Expect.equals(3, map.length);
-  Expect.equals(7, map[99]);
-  Expect.equals(42, map[50]);
-  Expect.equals(99, map[1]);
-  otherMap.remove(99);
-  map[99] = 0;
+  Expect.equals(7, map['99']);
+  Expect.equals(42, map['50']);
+  Expect.equals(99, map['1']);
+  otherMap.remove('99');
+  map['99'] = 0;
   map.addAll(otherMap);
   Expect.equals(3, map.length);
-  Expect.equals(0, map[99]);
-  Expect.equals(42, map[50]);
-  Expect.equals(99, map[1]);
+  Expect.equals(0, map['99']);
+  Expect.equals(42, map['50']);
+  Expect.equals(99, map['1']);
   map.clear();
   otherMap.clear();
   map.addAll(otherMap);
   Expect.equals(0, map.length);
 }
 
 void testDeletedElement(Map map) {
   map.clear();
   for (int i = 0; i < 100; i++) {
-    map[1] = 2;
+    map['1'] = 2;
     testLength(1, map);
-    map.remove(1);
+    map.remove('1');
     testLength(0, map);
   }
   testLength(0, map);
 }
 
 void testMapLiteral() {
   Map m = {"a": 1, "b": 2, "c": 3};
   Expect.equals(3, m.length);
   int sum = 0;
   m.forEach((a, b) {
@@ skipping 425 matching lines @@
     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) {
-  var order = [0, 6, 4, 2, 7, 9, 7, 1, 2, 5, 3];
+  var order = ['0', '6', '4', '2', '7', '9', '7', '1', '2', '5', '3'];
   for (int i = 0; i < order.length; i++) map[order[i]] = i;
-  Expect.listEquals(map.keys.toList(), [0, 6, 4, 2, 7, 9, 1, 5, 3]);
+  Expect.listEquals(
+      map.keys.toList(), ['0', '6', '4', '2', '7', '9', '1', '5', '3']);
   Expect.listEquals(map.values.toList(), [0, 1, 2, 8, 6, 5, 7, 9, 10]);
 }
 
 void testOtherKeys(Map<int, int> map) {
   // Test that non-int keys are allowed in containsKey/remove/lookup.
   // Custom hash sets and tree sets must be constructed so they don't
   // use the equality/comparator on incompatible objects.
 
   // This should not throw in either checked or unchecked mode.
-  map[0] = 0;
-  map[1] = 1;
-  map[2] = 2;
   Expect.isFalse(map.containsKey("not an int"));
   Expect.isFalse(map.containsKey(1.5));
   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;
@@ skipping 91 matching lines @@
   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 [](Object 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 compareTo(dynamic other) => 0;
   int get hashCode => 0;
   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]);
   }
@@ skipping 28 matching lines @@
   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));
 }