Format all tests.

tests/corelib_strong/set_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 set_test;
 
-
 import 'package:expect/expect.dart';
 import "dart:collection";
 
 void testMain(Set create()) {
   testInts(create);
   testStrings(create);
   testInts(() => create().toSet());
   testStrings(() => create().toSet());
 }
 
@@ skipping 188 matching lines @@
 
   set2 = set.toSet()..clear();
   testLength(0, set2);
   Expect.isTrue(set2.add(11));
   Expect.isTrue(set2.add(1));
   Expect.isTrue(set2.add(21));
   Expect.isTrue(set2.add(31));
   testLength(4, set2);
   Expect.listEquals(set.toList(), set2.toList());
 
-  set2 = (set.toSet()..clear()).toSet();  // Cloning empty set shouldn't fail.
+  set2 = (set.toSet()..clear()).toSet(); // Cloning empty set shouldn't fail.
   testLength(0, set2);
 }
 
 void testLength(int length, Set set) {
   Expect.equals(length, set.length);
   (length == 0 ? Expect.isTrue : Expect.isFalse)(set.isEmpty);
   (length != 0 ? Expect.isTrue : Expect.isFalse)(set.isNotEmpty);
   if (length == 0) {
-    for (var e in set) { Expect.fail("contains element when iterated: $e"); }
+    for (var e in set) {
+      Expect.fail("contains element when iterated: $e");
+    }
   }
   (length == 0 ? Expect.isFalse : Expect.isTrue)(set.iterator.moveNext());
 }
 
 void testStrings(Set create()) {
   var set = create();
   var strings = ["foo", "bar", "baz", "qux", "fisk", "hest", "svin", "pigvar"];
   set.addAll(strings);
   testLength(8, set);
   set.removeAll(strings.where((x) => x.length == 3));
@@ skipping 38 matching lines @@
   // It must not throw away equal elements that are different in the
   // equality of the set.
   // It must not consider objects to be not there if they are equal
   // in the equality of the set.
 
   // If set equality is natural equality, using different but equal objects
   // must work. Can't use an identity set internally (as was done at some point
   // during development).
   Set set = create();
   set.addAll([new CE(0), new CE(1), new CE(2)]);
-  Expect.equals(3, set.length);  // All different.
+  Expect.equals(3, set.length); // All different.
   set.retainAll([new CE(0), new CE(2)]);
   Expect.equals(2, set.length);
   Expect.isTrue(set.contains(new CE(0)));
   Expect.isTrue(set.contains(new CE(2)));
 
   // If equality of set is identity, we can't internally use a non-identity
   // based set because it might throw away equal objects that are not identical.
   var elems = [new CE(0), new CE(1), new CE(2), new CE(0)];
   set = create(identical, null, null, identityCompare);
   set.addAll(elems);
@@ skipping 23 matching lines @@
   Expect.isTrue(set.contains(new CE(6)));
   Expect.isTrue(set.contains(new CE(8)));
 }
 
 void testDifferenceIntersection(create([equals, hashCode, validKey, compare])) {
   // Test that elements of intersection comes from receiver set.
   CE ce1a = new CE(1);
   CE ce1b = new CE(1);
   CE ce2 = new CE(2);
   CE ce3 = new CE(3);
-  Expect.equals(ce1a, ce1b);  // Sanity check.
+  Expect.equals(ce1a, ce1b); // Sanity check.
 
   var set1 = create();
   var set2 = create();
   set1.add(ce1a);
   set1.add(ce2);
   set2.add(ce1b);
   set2.add(ce3);
 
   var difference = set1.difference(set2);
   testLength(1, difference);
   Expect.identical(ce2, difference.lookup(ce2));
 
   difference = set2.difference(set1);
   testLength(1, difference);
   Expect.identical(ce3, difference.lookup(ce3));
 
   // Difference uses other.contains to check for equality.
   var set3 = create(identical, identityHashCode, null, identityCompare);
   set3.add(ce1b);
   difference = set1.difference(set3);
-  testLength(2, difference);  // ce1a is not identical to element in set3.
+  testLength(2, difference); // ce1a is not identical to element in set3.
   Expect.identical(ce1a, difference.lookup(ce1a));
   Expect.identical(ce2, difference.lookup(ce2));
 
   // Intesection always takes elements from receiver set.
   var intersection = set1.intersection(set2);
   testLength(1, intersection);
   Expect.identical(ce1a, intersection.lookup(ce1a));
 
   intersection = set1.intersection(set3);
   testLength(0, intersection);
 }
 
 // Objects that are equal based on data.
 class CE implements Comparable<CE> {
   final int id;
   const CE(this.id);
   int get hashCode => id;
-  bool operator==(Object other) => other is CE && id == (other as CE).id;
+  bool operator ==(Object other) => other is CE && id == (other as CE).id;
   int compareTo(CE other) => id - other.id;
   String toString() => "CE($id)";
 }
 
 typedef int CECompare(CE e1, CE e2);
 // Equality of Id objects based on id modulo value.
 Function customEq(int mod) => (CE e1, CE e2) => ((e1.id - e2.id) % mod) == 0;
 Function customHash(int mod) => (CE e) => e.id % mod;
-CECompare customCompare(int mod) => (CE e1, CE e2) =>
-    (e1.id % mod) - (e2.id % mod);
+CECompare customCompare(int mod) =>
+    (CE e1, CE e2) => (e1.id % mod) - (e2.id % mod);
 bool validKey(Object o) => o is CE;
 final customId = new Map<dynamic, dynamic>.identity();
 int counter = 0;
 int identityCompare(e1, e2) {
   if (identical(e1, e2)) return 0;
   int i1 = customId.putIfAbsent(e1, () => ++counter);
   int i2 = customId.putIfAbsent(e2, () => ++counter);
   return i1 - i2;
 }
 
@@ skipping 33 matching lines @@
 
   Iterable<num> numIter = numList.where((x) => true);
   Set<int> set3 = setFrom(numIter);
   Expect.listEquals(numList, set3.toList()..sort());
 
   Set<int> set4 = setFrom(new Iterable.generate(0));
   Expect.isTrue(set4.isEmpty);
 }
 
 void testCESetFrom(setFrom) {
-  var ceList = [new CE(2), new CE(3), new CE(5),
-                new CE(7), new CE(11), new CE(13)];
+  var ceList = [
+    new CE(2),
+    new CE(3),
+    new CE(5),
+    new CE(7),
+    new CE(11),
+    new CE(13)
+  ];
 
   Set<CE> set1 = setFrom(ceList);
   Expect.listEquals(ceList, set1.toList()..sort());
 
   Set<CE> ceSet = ceList.toSet();
   Set<CE> set2 = setFrom(ceSet);
   Expect.listEquals(ceList, set2.toList()..sort());
 
   Iterable<CE> ceIter = ceList.where((x) => true);
   Set<CE> set3 = setFrom(ceIter);
   Expect.listEquals(ceList, set3.toList()..sort());
 
   Set<CE> set4 = setFrom(new Iterable.generate(0));
   Expect.isTrue(set4.isEmpty);
 }
 
 class A {}
+
 class B {}
+
 class C implements A, B {}
 
 void testASetFrom(setFrom) {
-  List<B> bList= <B>[new C()];
+  List<B> bList = <B>[new C()];
   // Set.from allows to cast elements.
   Set<A> aSet = setFrom(bList);
   Expect.isTrue(aSet.length == 1);
 }
 
 main() {
   testMain(() => new HashSet());
   testMain(() => new LinkedHashSet());
   testMain(() => new HashSet.identity());
   testMain(() => new LinkedHashSet.identity());
   testMain(() => new HashSet(equals: identical));
   testMain(() => new LinkedHashSet(equals: identical));
-  testMain(() => new HashSet(equals: (a, b) => a == b,
-                             hashCode: (a) => -a.hashCode,
-                             isValidKey: (a) => true));
+  testMain(() => new HashSet(
+      equals: (a, b) => a == b,
+      hashCode: (a) => -a.hashCode,
+      isValidKey: (a) => true));
   testMain(() => new LinkedHashSet(
       equals: (a, b) => a == b,
       hashCode: (a) => -a.hashCode,
       isValidKey: (a) => true));
   testMain(() => new SplayTreeSet());
 
   testIdentity(() => new HashSet.identity());
   testIdentity(() => new LinkedHashSet.identity());
   testIdentity(() => new HashSet(equals: identical));
   testIdentity(() => new LinkedHashSet(equals: identical));
   testIdentity(() => new SplayTreeSet(identityCompare));
 
   testTypeAnnotations(new HashSet<int>());
   testTypeAnnotations(new LinkedHashSet<int>());
   testTypeAnnotations(new HashSet<int>(equals: identical));
   testTypeAnnotations(new LinkedHashSet<int>(equals: identical));
-  testTypeAnnotations(new HashSet<int>(equals: (int a, int b) => a == b,
-                                       hashCode: (int a) => a.hashCode,
-                                       isValidKey: (a) => a is int));
-  testTypeAnnotations(new LinkedHashSet<int>(equals: (int a, int b) => a == b,
-                                             hashCode: (int a) => a.hashCode,
-                                             isValidKey: (a) => a is int));
+  testTypeAnnotations(new HashSet<int>(
+      equals: (int a, int b) => a == b,
+      hashCode: (int a) => a.hashCode,
+      isValidKey: (a) => a is int));
+  testTypeAnnotations(new LinkedHashSet<int>(
+      equals: (int a, int b) => a == b,
+      hashCode: (int a) => a.hashCode,
+      isValidKey: (a) => a is int));
   testTypeAnnotations(new SplayTreeSet<int>());
 
   testRetainWhere(([equals, hashCode, validKey, comparator]) =>
       new HashSet(equals: equals, hashCode: hashCode, isValidKey: validKey));
   testRetainWhere(([equals, hashCode, validKey, comparator]) =>
-      new LinkedHashSet(equals: equals, hashCode: hashCode,
-                        isValidKey: validKey));
+      new LinkedHashSet(
+          equals: equals, hashCode: hashCode, isValidKey: validKey));
   testRetainWhere(([equals, hashCode, validKey, comparator]) =>
       new SplayTreeSet(comparator, validKey));
 
   testDifferenceIntersection(([equals, hashCode, validKey, comparator]) =>
       new HashSet(equals: equals, hashCode: hashCode, isValidKey: validKey));
   testDifferenceIntersection(([equals, hashCode, validKey, comparator]) =>
-      new LinkedHashSet(equals: equals, hashCode: hashCode,
-                        isValidKey: validKey));
+      new LinkedHashSet(
+          equals: equals, hashCode: hashCode, isValidKey: validKey));
   testDifferenceIntersection(([equals, hashCode, validKey, comparator]) =>
       new SplayTreeSet(comparator, validKey));
 
   testIntSetFrom((x) => new Set<int>.from(x));
   testIntSetFrom((x) => new HashSet<int>.from(x));
   testIntSetFrom((x) => new LinkedHashSet<int>.from(x));
   testIntSetFrom((x) => new SplayTreeSet<int>.from(x));
 
   testCESetFrom((x) => new Set<CE>.from(x));
   testCESetFrom((x) => new HashSet<CE>.from(x));
   testCESetFrom((x) => new LinkedHashSet<CE>.from(x));
   testCESetFrom((x) => new SplayTreeSet<CE>.from(x));
 
-  testCESetFrom((x) => new SplayTreeSet<CE>.from(x,
-                                                 customCompare(20), validKey));
+  testCESetFrom(
+      (x) => new SplayTreeSet<CE>.from(x, customCompare(20), validKey));
   testCESetFrom((x) => new SplayTreeSet<CE>.from(x, identityCompare));
 
   testASetFrom((x) => new Set<A>.from(x));
   testASetFrom((x) => new HashSet<A>.from(x));
   testASetFrom((x) => new LinkedHashSet<A>.from(x));
   testASetFrom((x) => new SplayTreeSet<A>.from(x, identityCompare));
 }