Add EnumSet.

tests/compiler/dart2js/enumset_test.dart

Index: tests/compiler/dart2js/enumset_test.dart
diff --git a/tests/compiler/dart2js/enumset_test.dart b/tests/compiler/dart2js/enumset_test.dart
new file mode 100644
index 0000000000000000000000000000000000000000..66fad2e38e4b8e0ec7e4977fc92bbca22547af56
--- /dev/null
+++ b/tests/compiler/dart2js/enumset_test.dart
@@ -0,0 +1,150 @@
+// Copyright (c) 2016, 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 enumset.test;
+
+import 'package:compiler/src/util/enumset.dart';
+import 'package:expect/expect.dart';
+
+enum Enum { A, B, C, D, E, F, }
+
+main() {
+  testAddRemoveContains();
+  testConstructorsIntersects();
+}
+
+
+void checkEnumSet(EnumSet<Enum> enumSet,
+                 int expectedValue,
+                 List<Enum> expectedValues,
+                 String expectedToString) {
+  Expect.equals(expectedValue, enumSet.value,
+      "Unexpected EnumSet.value for ${enumSet.iterable(Enum.values)}");
+  Expect.listEquals(expectedValues, enumSet.iterable(Enum.values).toList(),
+      "Unexpected values: ${enumSet.iterable(Enum.values)}");
+  Expect.equals(expectedValues.isEmpty, enumSet.isEmpty,
+      "Unexpected EnumSet.isEmpty for ${enumSet.iterable(Enum.values)}");
+  Expect.equals(expectedToString, enumSet.toString(),
+      "Unexpected EnumSet.toString for ${enumSet.iterable(Enum.values)}");
+  for (Enum value in Enum.values) {
+    Expect.equals(expectedValues.contains(value), enumSet.contains(value),
+        "Unexpected EnumSet.contains for $value in "
+        "${enumSet.iterable(Enum.values)}");
+  }
+}
+
+void testAddRemoveContains() {
+  EnumSet<Enum> enumSet = new EnumSet<Enum>();
+
+  void check(int expectedValue,
+             List<Enum> expectedValues,
+             String expectedToString) {
+    checkEnumSet(enumSet, expectedValue, expectedValues, expectedToString);
+  }
+
+  check(0, [], '0');
+
+  enumSet.add(Enum.B);
+  check(2, [Enum.B], '10');
+
+  enumSet.add(Enum.F);
+  check(34, [Enum.F, Enum.B], '100010');
+
+  enumSet.add(Enum.A);
+  check(35, [Enum.F, Enum.B, Enum.A], '100011');
+
+  enumSet.add(Enum.A);
+  check(35, [Enum.F, Enum.B, Enum.A], '100011');
+
+  enumSet.remove(Enum.C);
+  check(35, [Enum.F, Enum.B, Enum.A], '100011');
+
+  enumSet.remove(Enum.B);
+  check(33, [Enum.F, Enum.A], '100001');
+
+  enumSet.remove(Enum.A);
+  check(32, [Enum.F], '100000');
+
+  enumSet.clear();
+  check(0, [], '0');
+
+  enumSet.add(Enum.A);
+  enumSet.add(Enum.B);
+  enumSet.add(Enum.C);
+  enumSet.add(Enum.D);
+  enumSet.add(Enum.E);
+  enumSet.add(Enum.F);
+  check(63, [Enum.F, Enum.E, Enum.D, Enum.C, Enum.B, Enum.A], '111111');
+}
+
+void testConstructorsIntersects() {
+  EnumSet<Enum> emptyA = new EnumSet<Enum>();
+  EnumSet<Enum> emptyB = new EnumSet<Enum>.fromValue(0);
+  EnumSet<Enum> emptyC = const EnumSet<Enum>.fixed(0);
+  EnumSet<Enum> emptyD = new EnumSet<Enum>.fixed(0);
+
+
+  void checkIntersects(EnumSet<Enum> a, EnumSet<Enum> b, bool expectedValue) {
+    Expect.equals(expectedValue, a.intersects(b),
+        "Unexpected intersects of $a and $b");
+    Expect.equals(a.intersects(b), b.intersects(a),
+        "Unsymmetric intersects of $a and $b");
+  }
+
+  void check(EnumSet<Enum> a, EnumSet<Enum> b) {
+    Expect.equals(a.value, b.value,
+        "Unexpected values of $a and $b");
+    Expect.equals(a.hashCode, b.hashCode,
+        "Unexpected hash codes of $a and $b");
+    Expect.equals(a, b,
+        "Unexpected equality of $a and $b");
+    checkIntersects(a, b, !a.isEmpty);
+  }
+
+  check(emptyA, emptyA);
+  check(emptyA, emptyB);
+  check(emptyA, emptyC);
+  check(emptyA, emptyD);
+
+  EnumSet<Enum> singleA = new EnumSet<Enum>()..add(Enum.C);
+  EnumSet<Enum> singleB = new EnumSet<Enum>.fromValue(4);
+  EnumSet<Enum> singleC = const EnumSet<Enum>.fixed(4);
+  EnumSet<Enum> singleD = new EnumSet<Enum>.fixed(4);
+  EnumSet<Enum> singleE = new EnumSet<Enum>.fromValues([Enum.C]);
+  EnumSet<Enum> singleF = new EnumSet<Enum>.fromValues([Enum.C], fixed: true);
+
+  check(singleA, singleA);
+  check(singleA, singleB);
+  check(singleA, singleC);
+  check(singleA, singleD);
+  check(singleA, singleE);
+  check(singleA, singleF);
+
+  EnumSet<Enum> multiA = new EnumSet<Enum>()
+      ..add(Enum.A)..add(Enum.D)..add(Enum.F);
+  EnumSet<Enum> multiB = new EnumSet<Enum>.fromValue(41);
+  EnumSet<Enum> multiC = const EnumSet<Enum>.fixed(41);
+  EnumSet<Enum> multiD = new EnumSet<Enum>.fixed(41);
+  EnumSet<Enum> multiE = new EnumSet<Enum>.fromValues([Enum.F, Enum.A, Enum.D]);
+  EnumSet<Enum> multiF =
+      new EnumSet<Enum>.fromValues([Enum.F, Enum.A, Enum.D], fixed: true);
+
+  check(multiA, multiA);
+  check(multiA, multiB);
+  check(multiA, multiC);
+  check(multiA, multiD);
+  check(multiA, multiE);
+  check(multiA, multiF);
+
+  EnumSet<Enum> multi2 = new EnumSet<Enum>.fromValues([Enum.F, Enum.A, Enum.C]);
+
+  checkIntersects(emptyA, singleA, false);
+  checkIntersects(emptyA, multiA, false);
+  checkIntersects(emptyA, multi2, false);
+
+  checkIntersects(singleA, multiA, false);
+  checkIntersects(singleA, multi2, true);
+
+  checkIntersects(multiA, multi2, true);
+}