Update to test package, make test work on dart2js.

test/equality_test.dart

 // Copyright (c) 2013, 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.
 
 // Tests equality utilities.
 
 import "dart:collection";
 import "package:collection/collection.dart";
-import "package:unittest/unittest.dart";
+import "package:test/test.dart";
 
 main() {
+  o(id) => new Element(id);
+
+  // Lists that are point-wise equal, but not identical.
+  var list1 = [o(1), o(2), o(3), o(4), o(5)];
+  var list2 = [o(1), o(2), o(3), o(4), o(5)];
+  // Similar length list with equal elements in different order.
+  var list3 = [o(1), o(3), o(5), o(4), o(2)];
+
   test("IterableEquality - List", () {
-    var l1 = [1, 2, 3, 4, 5];
-    var l2 = [1.0, 2.0, 3.0, 4.0, 5.0];
-    expect(const IterableEquality().equals(l1, l2), isTrue);
+    expect(const IterableEquality().equals(list1, list2), isTrue);
     Equality iterId = const IterableEquality(const IdentityEquality());
-    expect(iterId.equals(l1, l2), isFalse);  /// 01: ok

[Søren Gjesse, 2015/07/01 12:23:25]

Are these "status-file" comments leftovers, or should the .status file be
updated as well?

[Lasse Reichstein Nielsen, 2015/07/03 12:53:01]

They were basically left-overs because the status file was not brought into the
package repository when it was moved out of the sdk.

+    expect(iterId.equals(list1, list2), isFalse);
   });
 
   test("IterableEquality - LinkedSet", () {
-    var l1 = new LinkedHashSet.from([1, 2, 3, 4, 5]);
-    var l2 = new LinkedHashSet.from([1.0, 2.0, 3.0, 4.0, 5.0]);
+    var l1 = new LinkedHashSet.from(list1);
+    var l2 = new LinkedHashSet.from(list2);
     expect(const IterableEquality().equals(l1, l2), isTrue);
     Equality iterId = const IterableEquality(const IdentityEquality());
-    expect(iterId.equals(l1, l2), isFalse);  /// 02: ok
+    expect(iterId.equals(l1, l2), isFalse);
   });
 
   test("ListEquality", () {
-    var l1 = [1, 2, 3, 4, 5];
-    var l2 = [1.0, 2.0, 3.0, 4.0, 5.0];
-    expect(const ListEquality().equals(l1, l2),
+    expect(const ListEquality().equals(list1, list2),
            isTrue);
     Equality listId = const ListEquality(const IdentityEquality());
-    expect(listId.equals(l1, l2), isFalse);  /// 03: ok
+    expect(listId.equals(list1, list2), isFalse);
   });
 
   test("ListInequality length", () {
-    var l1 = [1, 2, 3, 4, 5];
-    var l2 = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0];
-    expect(const ListEquality().equals(l1, l2),
+    var list4 = [o(1), o(2), o(3), o(4), o(5), o(6)];
+    expect(const ListEquality().equals(list1, list4),
            isFalse);
-    expect(const ListEquality(const IdentityEquality()).equals(l1, l2),
+    expect(const ListEquality(const IdentityEquality()).equals(list1, list4),
            isFalse);
   });
 
   test("ListInequality value", () {
-    var l1 = [1, 2, 3, 4, 5];
-    var l2 = [1.0, 2.0, 3.0, 4.0, 6.0];
-    expect(const ListEquality().equals(l1, l2),
+    var list5 = [o(1), o(2), o(3), o(4), o(6)];
+    expect(const ListEquality().equals(list1, list5),
            isFalse);
-    expect(const ListEquality(const IdentityEquality()).equals(l1, l2),
+    expect(const ListEquality(const IdentityEquality()).equals(list1, list5),
            isFalse);
   });
 
   test("UnorderedIterableEquality", () {
-    var l1 = [1, 2, 3, 4, 5];
-    var l2 = [1.0, 3.0, 5.0, 4.0, 2.0];
-    expect(const UnorderedIterableEquality().equals(l1, l2),
+    expect(const UnorderedIterableEquality().equals(list1, list3),
            isTrue);
     Equality uniterId =
         const UnorderedIterableEquality(const IdentityEquality());
-    expect(uniterId.equals(l1, l2), isFalse);  /// 04: ok
+    expect(uniterId.equals(list1, list3), isFalse);
   });
 
   test("UnorderedIterableInequality length", () {
-    var l1 = [1, 2, 3, 4, 5];
-    var l2 = [1.0, 3.0, 5.0, 4.0, 2.0, 1.0];
-    expect(const UnorderedIterableEquality().equals(l1, l2),
+    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(l1, l2),
+               .equals(list1, list6),
            isFalse);
   });
 
   test("UnorderedIterableInequality values", () {
-    var l1 = [1, 2, 3, 4, 5];
-    var l2 = [1.0, 3.0, 5.0, 4.0, 6.0];
-    expect(const UnorderedIterableEquality().equals(l1, l2),
+    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(l1, l2),
+               .equals(list1, list7),
            isFalse);
   });
 
   test("SetEquality", () {
-    var l1 = new HashSet.from([1, 2, 3, 4, 5]);
-    var l2 = new LinkedHashSet.from([1.0, 3.0, 5.0, 4.0, 2.0]);
-    expect(const SetEquality().equals(l1, l2),
-           isTrue);
+    var set1 = new HashSet.from(list1);
+    var set2 = new LinkedHashSet.from(list3);
+    expect(const SetEquality().equals(set1, set2), isTrue);
     Equality setId = const SetEquality(const IdentityEquality());
-    expect(setId.equals(l1, l2), isFalse);  /// 05: ok
+    expect(setId.equals(set1, set2), isFalse);
   });
 
   test("SetInequality length", () {
-    var l1 = new HashSet.from([1, 2, 3, 4, 5]);
-    var l2 = new LinkedHashSet.from([1.0, 3.0, 5.0, 4.0, 2.0, 6.0]);
-    expect(const SetEquality().equals(l1, l2),
+    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(const IdentityEquality()).equals(l1, l2),
+    expect(const SetEquality(const IdentityEquality()).equals(set1, set2),
            isFalse);
   });
 
   test("SetInequality value", () {
-    var l1 = new HashSet.from([1, 2, 3, 4, 5]);
-    var l2 = new LinkedHashSet.from([1.0, 3.0, 5.0, 4.0, 6.0]);
-    expect(const SetEquality().equals(l1, l2),
+    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(const IdentityEquality()).equals(l1, l2),
+    expect(const SetEquality(const IdentityEquality()).equals(set1, set2),
            isFalse);
   });
 
-  var map1a = {"x": [1, 2, 3], "y": [true, false, null]};
-  var map1b = {"x": [4.0, 5.0, 6.0], "y": [false, true, null]};
-  var map2a = {"x": [3.0, 2.0, 1.0], "y": [false, true, null]};
-  var map2b = {"x": [6, 5, 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.from(l1);
   var s2 = new Set.from([map2b, map2a]);
 
   test("RecursiveEquality", () {
     const unordered = const UnorderedIterableEquality();
     expect(unordered.equals(map1a["x"], map2a["x"]),
         isTrue);
     expect(unordered.equals(map1a["y"], map2a["y"]),
@@ skipping 29 matching lines @@
     expect(colleq.equals(map1a, map2a),
         isTrue);
     expect(colleq.equals(map1b, map2b),
         isTrue);
     expect(colleq.equals(l1, l2),
         isTrue);
     expect(colleq.equals(s1, s2),
         isTrue);
   });
 }
+
+/// Wrapper objects for an `id` value.
+///
+/// Compares the `id` value by equality and for comparison.
+/// Allows creating simple objects that are equal without being identical.
+class Element implements Comparable<Element> {
+  final Comparable id;
+  const Element(this.id);
+  int get hashCode => id.hashCode;
+  bool operator==(Object other) => other is Element && id == other.id;
+  int compareTo(other) => id.compareTo(other.id);
+}