Re-land "Format all multitests"

tests/isolate/message3_test.dart

 // Copyright (c) 2012, 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.
 
 // Dart test program for testing serialization of messages.
 // VMOptions=--enable_type_checks --enable_asserts
 
 library MessageTest;
+
 import 'dart:async';
 import 'dart:collection';
 import 'dart:isolate';
 import 'package:async_helper/async_helper.dart';
 import 'package:expect/expect.dart';
 import 'dart:typed_data';
 
 void echoMain(msg) {
   SendPort replyTo = msg[0];
   SendPort pong = msg[1];
@@ skipping 36 matching lines @@
   var gee = 123;
 }
 
 class E {
   Function fun;
   E(this.fun);
 
   static fooFun() => 499;
   instanceFun() => 1234;
 }
+
 barFun() => 42;
 
 class F {
   final field = "field";
   const F();
 }
 
 class G {
   final field;
   const G(this.field);
 }
 
 class Value {
   final val;
   Value(this.val);
 
-  operator==(other) {
+  operator ==(other) {
     if (other is! Value) return false;
     return other.val == val;
   }
 
   get hashCode => val;
 }
 
 void runTests(SendPort ping, Queue checks) {
   ping.send("abc");
   checks.add((x) => Expect.equals("abc", x));
@@ skipping 14 matching lines @@
   fixed[0] = 0;
   fixed[1] = 1;
   ping.send(fixed);
   checks.add((x) {
     Expect.isTrue(x is List);
     Expect.listEquals([0, 1], x);
     // List must be mutable.
     x[0] = 3;
     Expect.equals(3, x[0]);
     // List must be fixed length.
-    Expect.throws(() { x.add(5); });
+    Expect.throws(() {
+      x.add(5);
+    });
   });
 
   List cyclic = [];
   cyclic.add(cyclic);
   ping.send(cyclic);
   checks.add((x) {
     Expect.isTrue(x is List);
     Expect.equals(1, x.length);
     Expect.identical(x, x[0]);
     // List must be mutable.
@@ skipping 48 matching lines @@
   ping.send(byteBuffer); // //# byteBuffer: ok
   checks.add( //            //# byteBuffer: ok
   (x) {
     Expect.isTrue(x is ByteBuffer);
     Uint16List uint16View = new Uint16List.view(x);
     Expect.equals(2, uint16View.length);
     Expect.equals(0, uint16View[0]);
     Expect.equals(1, uint16View[1]);
   }
   ) //                      //# byteBuffer: ok
-  ;
+      ;
 
   Int32x4List list32x4 = new Int32x4List(2);
   list32x4[0] = new Int32x4(1, 2, 3, 4);
   list32x4[1] = new Int32x4(5, 6, 7, 8);
   ping.send(list32x4); //   //# int32x4: ok
   checks.add( //            //# int32x4: ok
   (x) {
     Expect.isTrue(x is Int32x4List);
     Expect.equals(2, x.length);
     Int32x4 entry1 = x[0];
     Int32x4 entry2 = x[1];
     Expect.equals(1, entry1.x);
     Expect.equals(2, entry1.y);
     Expect.equals(3, entry1.z);
     Expect.equals(4, entry1.w);
     Expect.equals(5, entry2.x);
     Expect.equals(6, entry2.y);
     Expect.equals(7, entry2.z);
     Expect.equals(8, entry2.w);
   }
   ) //                    //# int32x4: ok
-  ;
+      ;
 
   ping.send({"foo": 499, "bar": 32});
   checks.add((x) {
     Expect.isTrue(x is LinkedHashMap);
     Expect.listEquals(["foo", "bar"], x.keys.toList());
     Expect.listEquals([499, 32], x.values.toList());
     Expect.equals(499, x["foo"]);
     Expect.equals(32, x["bar"]);
     // Must be mutable.
     x["foo"] = 22;
@@ skipping 162 matching lines @@
     Expect.identical(constF, x); // //# constInstance: ok
   });
 
   G g1 = new G(nonConstF);
   G g2 = new G(constF);
   G g3 = const G(constF);
   ping.send(g1);
   ping.send(g2);
   ping.send(g3);
 
-  checks.add((x) {  // g1.
+  checks.add((x) {
+    // g1.
     Expect.isTrue(x is G);
     Expect.isFalse(identical(g1, x));
     F f = x.field;
     Expect.equals("field", f.field);
     Expect.isFalse(identical(nonConstF, f));
   });
-  checks.add((x) {  // g2.
+  checks.add((x) {
+    // g2.
     Expect.isTrue(x is G);
     Expect.isFalse(identical(g1, x));
     F f = x.field;
     Expect.equals("field", f.field);
     Expect.identical(constF, f); // //# constInstance: continued
   });
-  checks.add((x) {  // g3.
+  checks.add((x) {
+    // g3.
     Expect.isTrue(x is G);
     Expect.identical(g3, x); // //# constInstance: continued
     F f = x.field;
     Expect.equals("field", f.field);
     Expect.identical(constF, f); // //# constInstance: continued
   });
 
   // Make sure objects in a map are serialized and deserialized in the correct
   // order.
   Map m = new Map();
@@ skipping 28 matching lines @@
     Function check = checks.removeFirst();
     check(msg);
     if (checks.isEmpty) {
       completer.complete();
       testPort.close();
     }
   });
 
   ReceivePort initialReplyPort = new ReceivePort();
   Isolate
-    .spawn(echoMain, [initialReplyPort.sendPort, testPort.sendPort])
-    .then((_) => initialReplyPort.first)
-    .then((SendPort ping) {
-      runTests(ping, checks);
-      Expect.isTrue(checks.length > 0);
-      completer.future
-        .then((_) => ping.send("halt"))
-        .then((_) => asyncEnd());
-    });
+      .spawn(echoMain, [initialReplyPort.sendPort, testPort.sendPort])
+      .then((_) => initialReplyPort.first)
+      .then((SendPort ping) {
+        runTests(ping, checks);
+        Expect.isTrue(checks.length > 0);
+        completer.future.then((_) => ping.send("halt")).then((_) => asyncEnd());
+      });
 }