Format all tests.

tests/isolate/function_send_test.dart

 // Copyright (c) 2014, 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:isolate";
 import "dart:async";
 import "package:expect/expect.dart";
 import "package:async_helper/async_helper.dart";
 
-void toplevel(port, message) { port.send("toplevel:$message"); }
-Function createFuncToplevel() => (p, m) { p.send(m); };
+void toplevel(port, message) {
+  port.send("toplevel:$message");
+}
+
+Function createFuncToplevel() => (p, m) {
+      p.send(m);
+    };
+
 class C {
   Function initializer;
   Function body;
-  C() : initializer = ((p, m) { throw "initializer"; }) {
-    body = (p, m) { throw "body"; };
+  C()
+      : initializer = ((p, m) {
+          throw "initializer";
+        }) {
+    body = (p, m) {
+      throw "body";
+    };
   }
-  static void staticFunc(port, message) { port.send("static:$message"); }
-  static Function createFuncStatic() => (p, m) { throw "static expr"; };
-  void instanceMethod(p, m) { throw "instanceMethod"; }
-  Function createFuncMember() => (p, m) { throw "instance expr"; };
-  void call(n, p) { throw "C"; }
+  static void staticFunc(port, message) {
+    port.send("static:$message");
+  }
+
+  static Function createFuncStatic() => (p, m) {
+        throw "static expr";
+      };
+  void instanceMethod(p, m) {
+    throw "instanceMethod";
+  }
+
+  Function createFuncMember() => (p, m) {
+        throw "instance expr";
+      };
+  void call(n, p) {
+    throw "C";
+  }
 }
 
 class Callable {
-  void call(p, m) { p.send(["callable", m]); }
+  void call(p, m) {
+    p.send(["callable", m]);
+  }
 }
 
-
 void main() {
   asyncStart();
 
   // Sendables are top-level functions and static functions only.
   testSendable("toplevel", toplevel);
   testSendable("static", C.staticFunc);
   // Unsendables are any closure - instance methods or function expression.
   var c = new C();
   testUnsendable("instance method", c.instanceMethod);
   testUnsendable("static context expression", createFuncToplevel());
@@ skipping 26 matching lines @@
   testUnsendable("callable object", new Callable().call);
 
   asyncEnd();
   return;
 }
 
 // Create a receive port that expects exactly one message.
 // Pass the message to `callback` and return the sendPort.
 SendPort singleMessagePort(callback) {
   var p;
-  p = new RawReceivePort((v) { p.close(); callback(v); });
+  p = new RawReceivePort((v) {
+    p.close();
+    callback(v);
+  });
   return p.sendPort;
 }
 
 // A singleMessagePort that expects the message to be a specific value.
 SendPort expectMessagePort(message) {
   asyncStart();
   return singleMessagePort((v) {
     Expect.equals(message, v);
     asyncEnd();
   });
 }
 
 void testSendable(name, func) {
   // Function as spawn message.
   Isolate.spawn(callFunc, [func, expectMessagePort("$name:spawn"), "spawn"]);
 
   // Send function to same isolate.
   var reply = expectMessagePort("$name:direct");
   singleMessagePort(callFunc).send([func, reply, "direct"]);
 
   // Send function to other isolate, call it there.
   reply = expectMessagePort("$name:other isolate");
   callPort().then((p) {
     p.send([func, reply, "other isolate"]);
   });
 
   // Round-trip function trough other isolate.
   echoPort((roundtripFunc) {
     Expect.identical(func, roundtripFunc, "$name:send through isolate");
-  }).then((port) { port.send(func); });
+  }).then((port) {
+    port.send(func);
+  });
 }
 
 // Creates a new isolate and a pair of ports that expect a single message
 // to be sent to the other isolate and back to the callback function.
 Future<SendPort> echoPort(callback(value)) {
   Completer completer = new Completer<SendPort>();
   SendPort replyPort = singleMessagePort(callback);
   RawReceivePort initPort;
   initPort = new RawReceivePort((p) {
     completer.complete(p);
     initPort.close();
   });
-  return Isolate.spawn(_echo, [replyPort, initPort.sendPort])
-                .then((isolate) => completer.future);
+  return Isolate.spawn(_echo, [replyPort, initPort.sendPort]).then(
+      (isolate) => completer.future);
 }
 
 void _echo(msg) {
   var replyPort = msg[0];
   RawReceivePort requestPort;
   requestPort = new RawReceivePort((msg) {
     replyPort.send(msg);
-    requestPort.close();  // Single echo only.
+    requestPort.close(); // Single echo only.
   });
   msg[1].send(requestPort.sendPort);
 }
 
 // Creates other isolate that waits for a single message, `msg`, on the returned
 // port, and executes it as `msg[0](msg[1],msg[2])` in the other isolate.
 Future<SendPort> callPort() {
   Completer completer = new Completer<SendPort>();
   SendPort initPort = singleMessagePort(completer.complete);
-  return Isolate.spawn(_call, initPort)
-                .then((_) => completer.future);
+  return Isolate.spawn(_call, initPort).then((_) => completer.future);
 }
 
 void _call(initPort) {
   initPort.send(singleMessagePort(callFunc));
 }
 
 void testUnsendable(name, func) {
   asyncStart();
   Isolate.spawn(nop, func).then((v) => throw "allowed spawn direct?",
-                                onError: (e,s){ asyncEnd(); });
+      onError: (e, s) {
+    asyncEnd();
+  });
   asyncStart();
   Isolate.spawn(nop, [func]).then((v) => throw "allowed spawn wrapped?",
-                                  onError: (e,s){ asyncEnd(); });
+      onError: (e, s) {
+    asyncEnd();
+  });
 
   asyncStart();
-  var noReply = new RawReceivePort((_) { throw "Unexpected message: $_"; });
+  var noReply = new RawReceivePort((_) {
+    throw "Unexpected message: $_";
+  });
   Expect.throws(() {
     noReply.sendPort.send(func);
   }, null, "send direct");
   Expect.throws(() {
     noReply.sendPort.send([func]);
   }, null, "send wrapped");
   scheduleMicrotask(() {
     noReply.close();
     asyncEnd();
   });
 
   // Try sending through other isolate.
   asyncStart();
-  echoPort((v) { Expect.equals(0, v); })
-    .then((p) {
-      try {
-        p.send(func);
-      } finally {
-        p.send(0); //   Closes echo port.
-      }
-    })
-    .then((p) => throw "unreachable 2",
-          onError: (e, s) {asyncEnd();});
+  echoPort((v) {
+    Expect.equals(0, v);
+  }).then((p) {
+    try {
+      p.send(func);
+    } finally {
+      p.send(0); //   Closes echo port.
+    }
+  }).then((p) => throw "unreachable 2", onError: (e, s) {
+    asyncEnd();
+  });
 }
 
 void nop(_) {}
 
 void callFunc(message) {
   message[0](message[1], message[2]);
 }