Re-land "Format all multitests"

tests/corelib_strong/list_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.
 
 import "dart:collection";
 import "dart:typed_data";
 import "package:expect/expect.dart";
 
 void main() {
   // Typed lists - fixed length and can only contain integers.
@@ skipping 45 matching lines @@
   testIndexError(list, index, name) {
     try {
       list[list.length];
     } catch (err, s) {
       Expect.isTrue(err is RangeError, "$name[$index]");
       Expect.equals(list.length, err.invalidValue, "$name[$index] value");
       Expect.equals(list.length - 1, err.end, "$name[$index] end");
       Expect.equals(0, err.start, "$name[$index] start");
     }
   }
+
   testIndex(list, name) {
     testIndexError(list, list.length, name); //   Just too big.
     testIndexError(list, -1, name); //            Negative.
     testIndexError(list, 0x123456789, name); //   > 2^32.
     testIndexError(list, -0x123456789, name); //  < -2^32.
   }
 
   // Slices.
   testSliceError(list, start, end, name) {
     name = "$name[$start:$end]";
     var realError;
     try {
       RangeError.checkValidRange(start, end, list.length);
     } catch (e) {
       realError = e;
     }
     var result;
     try {
       result = list.sublist(start, end);
     } catch (actualError) {
       Expect.isNotNull(realError, "$name should not fail");
       Expect.isTrue(actualError is RangeError, "$name is-error: $actualError");
       Expect.equals(realError.name, actualError.name, "$name name");
       Expect.equals(realError.invalidValue, actualError.invalidValue,
-                    "$name[0:l+1] value");
+          "$name[0:l+1] value");
       Expect.equals(realError.start, actualError.start, "$name[0:l+1] start");
       Expect.equals(realError.end, actualError.end, "$name[0:l+1] end");
       return;
     }
     // Didn't throw.
     Expect.isNull(realError, "$name should fail");
     Expect.equals(end - start, result.length, "$name result length");
   }
 
   testSlice(list, name) {
-    testSliceError(list, 0, list.length, name);  // Should not fail.
+    testSliceError(list, 0, list.length, name); // Should not fail.
     testSliceError(list, 0, list.length + 1, name);
     testSliceError(list, 0, 0x123456789, name);
     testSliceError(list, -1, list.length, name);
     testSliceError(list, -0x123456789, list.length, name);
     testSliceError(list, list.length + 1, list.length + 1, name);
     testSliceError(list, -1, null, name);
     if (list.length > 0) {
       testSliceError(list, list.length, list.length - 1, name);
     }
   }
 
   testRangeErrors(list, name) {
     testIndex(list, "$name#${list.length} index");
     testSlice(list, "$name#${list.length} slice");
   }
+
   // Empty lists.
   testRangeErrors([], "list");
   testRangeErrors(new List(0), "fixed-list");
   testRangeErrors(const [], "const-list");
   testRangeErrors(new List.unmodifiable([]), "unmodifiable");
   testRangeErrors(new Uint8List(0), "typed-list");
   testRangeErrors(new Uint8List.view(new Uint8List(0).buffer), "typed-list");
   testRangeErrors([1, 2, 3].sublist(1, 1), "sub-list");
   // Non-empty lists.
   testRangeErrors([1, 2, 3], "list");
@@ skipping 66 matching lines @@
   Expect.listEquals([9, 9, 9, 9], list);
 
   // sort.
   list.setRange(0, 4, [3, 2, 1, 0]);
   list.sort();
   Expect.listEquals([0, 1, 2, 3], list);
   list.setRange(0, 4, [1, 2, 3, 0]);
   list.sort();
   Expect.listEquals([0, 1, 2, 3], list);
   list.setRange(0, 4, [1, 3, 0, 2]);
-  list.sort((a, b) => b - a);  // reverse compare.
+  list.sort((a, b) => b - a); // reverse compare.
   Expect.listEquals([3, 2, 1, 0], list);
   list.setRange(0, 4, [1, 2, 3, 0]);
   list.sort((a, b) => b - a);
   Expect.listEquals([3, 2, 1, 0], list);
 
   // Some Iterable methods.
 
   list.setRange(0, 4, [0, 1, 2, 3]);
   // map.
-  testMap(val) {return val * 2 + 10; }
+  testMap(val) {
+    return val * 2 + 10;
+  }
+
   List mapped = list.map(testMap).toList();
   Expect.equals(mapped.length, list.length);
   for (var i = 0; i < list.length; i++) {
     Expect.equals(mapped[i], list[i] * 2 + 10);
   }
 
   matchAll(val) => true;
-  matchSome(val) { return (val == 1 || val == 2); }
-  matchSomeFirst(val) { return val == 0; }
-  matchSomeLast(val) { return val == 3; }
+  matchSome(val) {
+    return (val == 1 || val == 2);
+  }
+
+  matchSomeFirst(val) {
+    return val == 0;
+  }
+
+  matchSomeLast(val) {
+    return val == 3;
+  }
+
   matchNone(val) => false;
 
   // where.
   Iterable filtered = list.where(matchSome);
   Expect.equals(filtered.length, 2);
 
   // every
   Expect.isTrue(list.every(matchAll));
   Expect.isFalse(list.every(matchSome));
   Expect.isFalse(list.every(matchNone));
@@ skipping 70 matching lines @@
 
 void testFixedLengthList(List list) {
   testLengthInvariantOperations(list);
   testCannotChangeLength(list);
 }
 
 void testCannotChangeLength(List list) {
   isUnsupported(action()) {
     Expect.throws(action, (e) => e is UnsupportedError);
   }
+
   isUnsupported(() => list.add(0));
   isUnsupported(() => list.addAll([0]));
   isUnsupported(() => list.removeLast());
   isUnsupported(() => list.insert(0, 1));
   isUnsupported(() => list.insertAll(0, [1]));
   isUnsupported(() => list.clear());
   isUnsupported(() => list.remove(1));
   isUnsupported(() => list.removeAt(1));
   isUnsupported(() => list.removeRange(0, 1));
   isUnsupported(() => list.replaceRange(0, 1, []));
@@ skipping 140 matching lines @@
   void testConcurrentModification(action()) {
     testIterator(int when) {
       list.length = 4;
       list.setAll(0, [0, 1, 2, 3]);
       Expect.throws(() {
         for (var element in list) {
           if (element == when) action();
         }
       }, (e) => e is ConcurrentModificationError);
     }
+
     testForEach(int when) {
       list.length = 4;
       list.setAll(0, [0, 1, 2, 3]);
       Expect.throws(() {
         list.forEach((var element) {
           if (element == when) action();
         });
       }, (e) => e is ConcurrentModificationError);
     }
+
     // Test the change at different points of the iteration.
     testIterator(0);
     testIterator(1);
     testIterator(3);
     testForEach(0);
     testForEach(1);
     testForEach(3);
   }
 
   testConcurrentModification(() => list.add(5));
@@ skipping 66 matching lines @@
 
 class Yes {
   operator ==(var other) => true;
   int get hashCode => 0;
 }
 
 class MyList<E> extends ListBase<E> {
   List<E> _source;
   MyList(this._source);
   int get length => _source.length;
-  void set length(int length) { _source.length = length; }
-  E operator[](int index) => _source[index];
-  void operator[]=(int index, E value) { _source[index] = value; }
+  void set length(int length) {
+    _source.length = length;
+  }
+
+  E operator [](int index) => _source[index];
+  void operator []=(int index, E value) {
+    _source[index] = value;
+  }
 }
 
 class MyFixedList<E> extends ListBase<E> {
   List<E> _source;
   MyFixedList(this._source);
   int get length => _source.length;
-  void set length(int length) { throw new UnsupportedError("Fixed length!"); }
-  E operator[](int index) => _source[index];
-  void operator[]=(int index, E value) { _source[index] = value; }
+  void set length(int length) {
+    throw new UnsupportedError("Fixed length!");
+  }
+
+  E operator [](int index) => _source[index];
+  void operator []=(int index, E value) {
+    _source[index] = value;
+  }
 }
 
 void testListConstructor() {
-  Expect.throws(() { new List(0).add(4); });  // Is fixed-length.
+  // Is fixed-length.
+  Expect.throws(() {
+    new List(0).add(4);
+  });
   Expect.throws(() { new List(-2); });  // Not negative. //# 01: ok
-  Expect.throws(() { new List(null); });  // Not null.
+  // Not null.
+  Expect.throws(() {
+    new List(null);
+  });
   Expect.listEquals([4], new List()..add(4));
-  Expect.throws(() { new List.filled(0, 42).add(4); });  // Is fixed-length.
-  Expect.throws(() { new List.filled(-2, 42); });  // Not negative.
-  Expect.throws(() { new List.filled(null, 42); });  // Not null.
+  // Is fixed-length.
+  Expect.throws(() {
+    new List.filled(0, 42).add(4);
+  });
+  // Not negative.
+  Expect.throws(() {
+    new List.filled(-2, 42);
+  });
+  // Not null.
+  Expect.throws(() {
+    new List.filled(null, 42);
+  });
 }