Add custom equals and hashCode for HashMap implementation.

tests/corelib/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';
 
 void main() {
   test(new HashMap());
@@ skipping 11 matching lines @@
   testWeirdStringKeys(new HashMap<String, String>());
   testWeirdStringKeys(new LinkedHashMap());
   testWeirdStringKeys(new LinkedHashMap<String, String>());
   testWeirdStringKeys(new SplayTreeMap());
   testWeirdStringKeys(new SplayTreeMap<String, String>());
 
   testNumericKeys(new Map());
   testNumericKeys(new Map<num, String>());
   testNumericKeys(new HashMap());
   testNumericKeys(new HashMap<num, String>());
+  testNumericKeys(new HashMap(equals: identical));
+  testNumericKeys(new HashMap<num, String>(equals: identical));
   testNumericKeys(new LinkedHashMap());
   testNumericKeys(new LinkedHashMap<num, String>());
+
+  testNaNKeys(new Map());
+  testNaNKeys(new Map<num, String>());
+  testNaNKeys(new HashMap());
+  testNaNKeys(new HashMap<num, String>());
+  testNaNKeys(new LinkedHashMap());
+  testNaNKeys(new LinkedHashMap<num, String>());
+  // Identity maps fail the NaN-keys tests because the test assumes that
+  // NaN is not equal to NaN.
+
+  testIdentityMap(new HashMap(equals: identical));
+
+  testCustomMap(new HashMap(equals: myEquals, hashCode: myHashCode));
+
+  testIterationOrder(new LinkedHashMap());
 }
 
 
 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");
 }
@@ skipping 322 matching lines @@
     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 testNaNKeys(Map map) {
+  Expect.isTrue(map.isEmpty);
   // Test NaN.
   var nan = double.NAN;
   Expect.isFalse(map.containsKey(nan));
   Expect.equals(null, map[nan]);
 
   map[nan] = 'value:0';
   Expect.isFalse(map.containsKey(nan));
   Expect.equals(null, map[nan]);
   testLength(1, map);
 
@@ skipping 13 matching lines @@
 
   map.clear();
   Expect.isTrue(map.isEmpty);
 }
 
 void testLength(int length, Map map) {
   Expect.equals(length, map.length);
   (length == 0 ? Expect.isTrue : Expect.isFalse)(map.isEmpty);
   (length != 0 ? Expect.isTrue : Expect.isFalse)(map.isNotEmpty);
 }
+
+
+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!
+
+  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]);
+
+  Expect.equals(1, map.remove(v1));
+  testLength(1, map);
+  Expect.isFalse(map.containsKey(v1));
+  Expect.isTrue(map.containsKey(v2));
+
+  Expect.isNull(map.remove(v1));
+  Expect.equals(2, map.remove(v2));
+  testLength(0, map);
+
+  var eq01 = new Equalizer(0);
+  var eq02 = new Equalizer(0);
+  var eq11 = new Equalizer(1);
+  var eq12 = new Equalizer(1);
+  // Sanity.
+  Expect.equals(eq01, eq02);
+  Expect.equals(eq02, eq01);
+  Expect.equals(eq11, eq12);
+  Expect.equals(eq12, eq11);
+  Expect.notEquals(eq01, eq11);
+  Expect.notEquals(eq01, eq12);
+  Expect.notEquals(eq02, eq11);
+  Expect.notEquals(eq02, eq12);
+  Expect.notEquals(eq11, eq01);
+  Expect.notEquals(eq11, eq02);
+  Expect.notEquals(eq12, eq01);
+  Expect.notEquals(eq12, eq02);
+
+  map[eq01] = 0;
+  map[eq02] = 1;
+  map[eq11] = 2;
+  map[eq12] = 3;
+  testLength(4, map);
+
+  Expect.equals(0, map[eq01]);
+  Expect.equals(1, map[eq02]);
+  Expect.equals(2, map[eq11]);
+  Expect.equals(3, map[eq12]);
+
+  Expect.isTrue(map.containsKey(eq01));
+  Expect.isTrue(map.containsKey(eq02));
+  Expect.isTrue(map.containsKey(eq11));
+  Expect.isTrue(map.containsKey(eq12));
+
+  Expect.equals(1, map.remove(eq02));
+  Expect.equals(3, map.remove(eq12));
+  testLength(2, map);
+  Expect.isTrue(map.containsKey(eq01));
+  Expect.isFalse(map.containsKey(eq02));
+  Expect.isTrue(map.containsKey(eq11));
+  Expect.isFalse(map.containsKey(eq12));
+
+  Expect.equals(0, map[eq01]);
+  Expect.equals(null, map[eq02]);
+  Expect.equals(2, map[eq11]);
+  Expect.equals(null, map[eq12]);
+
+  Expect.equals(0, map.remove(eq01));
+  Expect.equals(2, map.remove(eq11));
+  testLength(0, map);
+
+  map[eq01] = 0;
+  map[eq02] = 1;
+  map[eq11] = 2;
+  map[eq12] = 3;
+  testLength(4, map);
+
+  // Transfer to equality-based map will collapse elements.
+  Map eqMap = new HashMap();
+  eqMap.addAll(map);
+  testLength(2, eqMap);
+  Expect.isTrue(eqMap.containsKey(eq01));
+  Expect.isTrue(eqMap.containsKey(eq02));
+  Expect.isTrue(eqMap.containsKey(eq11));
+  Expect.isTrue(eqMap.containsKey(eq12));
+}
+
+/** 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) =>
+      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) =>
+      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.
+  Expect.equals(c11, c12);
+  Expect.notEquals(c11, c21);
+  Expect.notEquals(c11, c22);
+  Expect.equals(c21, c22);
+  Expect.notEquals(c21, c11);
+  Expect.notEquals(c21, c12);
+
+  Expect.isTrue(myEquals(c11, c21));
+  Expect.isFalse(myEquals(c11, c12));
+  Expect.isFalse(myEquals(c11, c22));
+  Expect.isTrue(myEquals(c12, c22));
+  Expect.isFalse(myEquals(c12, c11));
+  Expect.isFalse(myEquals(c12, c21));
+
+  map[c11] = 42;
+  testLength(1, map);
+  Expect.isTrue(map.containsKey(c11));
+  Expect.isTrue(map.containsKey(c21));
+  Expect.isFalse(map.containsKey(c12));
+  Expect.isFalse(map.containsKey(c22));
+  Expect.equals(42, map[c11]);
+  Expect.equals(42, map[c21]);
+
+  map[c21] = 37;
+  testLength(1, map);
+  Expect.isTrue(map.containsKey(c11));
+  Expect.isTrue(map.containsKey(c21));
+  Expect.isFalse(map.containsKey(c12));
+  Expect.isFalse(map.containsKey(c22));
+  Expect.equals(37, map[c11]);
+  Expect.equals(37, map[c21]);
+
+  map[c22] = 42;
+  testLength(2, map);
+  Expect.isTrue(map.containsKey(c11));
+  Expect.isTrue(map.containsKey(c21));
+  Expect.isTrue(map.containsKey(c12));
+  Expect.isTrue(map.containsKey(c22));
+  Expect.equals(37, map[c11]);
+  Expect.equals(37, map[c21]);
+  Expect.equals(42, map[c12]);
+  Expect.equals(42, map[c22]);
+
+  Expect.equals(42, map.remove(c12));
+  testLength(1, map);
+  Expect.isTrue(map.containsKey(c11));
+  Expect.isTrue(map.containsKey(c21));
+  Expect.isFalse(map.containsKey(c12));
+  Expect.isFalse(map.containsKey(c22));
+  Expect.equals(37, map[c11]);
+  Expect.equals(37, map[c21]);
+
+  Expect.equals(37, map.remove(c11));
+  testLength(0, map);
+}
+
+class Customer {
+  final int id;
+  final int secondId;
+  const Customer(this.id, this.secondId);
+  int get hashCode => id;
+  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;
+
+testIterationOrder(Map map) {
+  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.values.toList(), [0, 1, 2, 8, 6, 5, 7, 9, 10]);
+}