Format all tests.

tests/corelib/string_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 "package:expect/expect.dart";
 
 void main() {
   testOutOfRange();
   testIllegalArgument();
   testConcat();
@@ skipping 18 matching lines @@
   for (var i = 0; i < 20; i++) {
     testStringLength(i, str);
     str += " ";
   }
 }
 
 void testOutOfRange() {
   String a = "Hello";
   bool exception_caught = false;
   try {
-    var c = a[20];  // Throw exception.
+    var c = a[20]; // Throw exception.
   } on RangeError catch (e) {
     exception_caught = true;
   }
   Expect.isTrue(exception_caught);
 }
 
 void testIllegalArgument() {
   String a = "Hello";
   bool exception_caught = false;
   try {
-    var c = a[2.2];  // Throw exception.
+    var c = a[2.2]; // Throw exception.
     Expect.fail("Accepting double as index");
   } on ArgumentError catch (e) {
     exception_caught = true;
-  } on TypeError catch (e) {  // Thrown in checked mode only.
+  } on TypeError catch (e) {
+    // Thrown in checked mode only.
     exception_caught = true;
   }
   Expect.isTrue(exception_caught);
 }
 
 void testIndex() {
   String str = "string";
   for (int i = 0; i < str.length; i++) {
     Expect.isTrue(str[i] is String);
     testStringLength(1, str[i]);
@@ skipping 114 matching lines @@
   Expect.isTrue("str".startsWith(new RegExp("a?"), 3));
 
   Expect.throws(() => "str".startsWith(regexp, -1));
   Expect.throws(() => "str".startsWith(regexp, 4));
 
   regexp = new RegExp("^str");
   Expect.isTrue("strstr".startsWith(regexp));
   Expect.isTrue("strstr".startsWith(regexp, 0));
   Expect.isFalse("strstr".startsWith(regexp, 1));
   Expect.isFalse("strstr".startsWith(regexp, 2));
-  Expect.isFalse("strstr".startsWith(regexp, 3));  // Second "str" isn't at ^.
+  Expect.isFalse("strstr".startsWith(regexp, 3)); // Second "str" isn't at ^.
 }
 
 void testIndexOf() {
   Expect.equals(0, "str".indexOf("", 0));
   Expect.equals(0, "".indexOf("", 0));
   Expect.equals(-1, "".indexOf("a", 0));
 
   Expect.equals(1, "str".indexOf("t", 0));
   Expect.equals(1, "str".indexOf("tr", 0));
   Expect.equals(0, "str".indexOf("str", 0));
@@ skipping 61 matching lines @@
   Expect.equals(2, "str".lastIndexOf("r", 2));
   Expect.equals(-1, "str".lastIndexOf("string", 2));
 
   Expect.equals(4, "strstr".lastIndexOf("t", 5));
   Expect.equals(4, "strstr".lastIndexOf("tr", 5));
   Expect.equals(3, "strstr".lastIndexOf("str", 5));
   Expect.equals(3, "strstr".lastIndexOf("st", 5));
   Expect.equals(3, "strstr".lastIndexOf("s", 5));
   Expect.equals(5, "strstr".lastIndexOf("r", 5));
   Expect.throws(() {
-      "str".lastIndexOf("string", 5);
+    "str".lastIndexOf("string", 5);
   });
   Expect.equals(4, "strstr".lastIndexOf("t", 5));
   Expect.equals(4, "strstr".lastIndexOf("tr", 5));
   Expect.equals(3, "strstr".lastIndexOf("str", 5));
   Expect.equals(3, "strstr".lastIndexOf("str", 5));
   Expect.equals(3, "strstr".lastIndexOf("str", 5));
   Expect.equals(3, "strstr".lastIndexOf("st", 5));
   Expect.equals(3, "strstr".lastIndexOf("s", 5));
   Expect.equals(5, "strstr".lastIndexOf("r", 5));
   Expect.equals(2, "strstr".lastIndexOf("r", 4));
@@ skipping 38 matching lines @@
 
   Expect.isFalse("str".contains("sr", 0));
   Expect.isFalse("str".contains("string", 0));
 
   Expect.isTrue("str".contains("", 0));
   Expect.isTrue("".contains("", 0));
   Expect.isFalse("".contains("s", 0));
 }
 
 void testReplaceAll() {
-  Expect.equals(
-      "AtoBtoCDtoE", "AfromBfromCDfromE".replaceAll("from", "to"));
+  Expect.equals("AtoBtoCDtoE", "AfromBfromCDfromE".replaceAll("from", "to"));
 
   // Test with the replaced string at the begining.
-  Expect.equals(
-      "toABtoCDtoE", "fromABfromCDfromE".replaceAll("from", "to"));
+  Expect.equals("toABtoCDtoE", "fromABfromCDfromE".replaceAll("from", "to"));
 
   // Test with the replaced string at the end.
   Expect.equals(
       "toABtoCDtoEto", "fromABfromCDfromEfrom".replaceAll("from", "to"));
 
   // Test when there are no occurence of the string to replace.
   Expect.equals("ABC", "ABC".replaceAll("from", "to"));
 
   // Test when the string to change is the empty string.
   Expect.equals("", "".replaceAll("from", "to"));
@@ skipping 29 matching lines @@
 }
 
 void testCharCodes() {
   test(str) {
     var list = str.codeUnits;
     Expect.equals(str.length, list.length);
     for (int i = 0; i < str.length; i++) {
       Expect.equals(str.codeUnitAt(i), list[i]);
     }
   }
+
   test("abc");
   test("");
   test(" ");
 }
 
 void testStringLength(int length, String str) {
   Expect.equals(length, str.length);
   (length == 0 ? Expect.isTrue : Expect.isFalse)(str.isEmpty);
   (length != 0 ? Expect.isTrue : Expect.isFalse)(str.isNotEmpty);
 }
@@ skipping 41 matching lines @@
     } else if (repeat == 1) {
       expect = str;
     } else {
       StringBuffer buf = new StringBuffer();
       for (int i = 0; i < repeat; i++) {
         buf.write(str);
       }
       expect = buf.toString();
     }
     String actual = str * repeat;
-    Expect.equals(expect, actual,
-                  "$str#${str.length} * $repeat");
+    Expect.equals(expect, actual, "$str#${str.length} * $repeat");
   }
+
   for (String str in testStrings) {
     for (int repeat in counts) {
       testRepeat(str, repeat);
     }
   }
 }
 
 void testPadLeft() {
   Expect.equals("    1", "1".padLeft(5, ' '));
   Expect.equals("   11", "11".padLeft(5, ' '));
@@ skipping 26 matching lines @@
   Expect.equals('a', ''.padRight(1, 'a'));
   Expect.equals('aaaaa', ''.padRight(5, 'a'));
   Expect.equals('', ''.padRight(-2, 'a'));
 
   Expect.equals('xyzxyzxyzxyzxyz', ''.padRight(5, 'xyz'));
   Expect.equals('axyzxyzxyzxyz', 'a'.padRight(5, 'xyz'));
   Expect.equals('aaxyzxyzxyz', 'aa'.padRight(5, 'xyz'));
   Expect.equals('aa\u{10002}\u{10002}\u{10002}', 'aa'.padRight(5, '\u{10002}'));
   Expect.equals('a', 'a'.padRight(10, ''));
 }