adding codereview file, formatting, adding gitignore

test/ports_test.dart

 // Copyright (c) 2015, 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 dart.pkg.isolate.isolaterunner_test;
 
 import "package:isolate/ports.dart";
 import "package:unittest/unittest.dart";
 import "dart:async";
 import "dart:isolate";
@@ skipping 30 matching lines @@
     Completer completer = new Completer.sync();
     SendPort p = singleCallbackPort(completer.complete);
     p.send(42);
     return completer.future.then((v) {
       expect(v, 42);
     });
   });
 
   test("singleCallbackValueBeforeTimeout", () {
     Completer completer = new Completer.sync();
-    SendPort p = singleCallbackPort(completer.complete,
-                                    timeout: MS * 500);
+    SendPort p = singleCallbackPort(completer.complete, timeout: MS * 500);
     p.send(42);
     return completer.future.then((v) {
       expect(v, 42);
     });
   });
 
   test("singleCallbackTimeout", () {
     Completer completer = new Completer.sync();
-    singleCallbackPort(completer.complete,
-                       timeout: MS * 100,
-                       timeoutValue: 37);
+    singleCallbackPort(completer.complete, timeout: MS * 100, timeoutValue: 37);
     return completer.future.then((v) {
       expect(v, 37);
     });
   });
 
   test("singleCallbackTimeoutFirst", () {
     Completer completer = new Completer.sync();
     SendPort p = singleCallbackPort(completer.complete,
-                                    timeout: MS * 100,
-                                    timeoutValue: 37);
+        timeout: MS * 100, timeoutValue: 37);

[Lasse Reichstein Nielsen, 2015/02/26 10:59:15]

Indent to after '(' or put completer.complete on new line.

     new Timer(MS * 500, () => p.send(42));
     return completer.future.then((v) {
       expect(v, 37);
     });
   });
 }
 
-
 void testSingleCompletePort() {
   test("singleCompleteValue", () {
     Completer completer = new Completer.sync();
     SendPort p = singleCompletePort(completer);
     p.send(42);
     return completer.future.then((v) {
       expect(v, 42);
     });
   });
 
   test("singleCompleteValueCallback", () {
     Completer completer = new Completer.sync();
-    SendPort p = singleCompletePort(completer,
-                                    callback: (v) {
-                                      expect(42, v);
-                                      return 87;
-                                    });
+    SendPort p = singleCompletePort(completer, callback: (v) {
+      expect(42, v);
+      return 87;
+    });

[Lasse Reichstein Nielsen, 2015/02/26 10:59:15]

This is much better!

     p.send(42);
     return completer.future.then((v) {
       expect(v, 87);
     });
   });
 
   test("singleCompleteValueCallbackFuture", () {
     Completer completer = new Completer.sync();
-    SendPort p = singleCompletePort(completer,
-                                    callback: (v) {
-                                      expect(42, v);
-                                      return new Future.delayed(MS * 500,
-                                                                () => 88);
-                                    });
+    SendPort p = singleCompletePort(completer, callback: (v) {
+      expect(42, v);
+      return new Future.delayed(MS * 500, () => 88);
+    });
     p.send(42);
     return completer.future.then((v) {
       expect(v, 88);
     });
   });
 
   test("singleCompleteValueCallbackThrows", () {
     Completer completer = new Completer.sync();
-    SendPort p = singleCompletePort(completer,
-                                    callback: (v) {
-                                      expect(42, v);
-                                      throw 89;
-                                    });
+    SendPort p = singleCompletePort(completer, callback: (v) {
+      expect(42, v);
+      throw 89;
+    });
     p.send(42);
     return completer.future.then((v) {
       fail("unreachable");
     }, onError: (e, s) {
       expect(e, 89);
     });
   });
 
   test("singleCompleteValueCallbackThrowsFuture", () {
     Completer completer = new Completer.sync();
-    SendPort p = singleCompletePort(completer,
-                                    callback: (v) {
-                                      expect(42, v);
-                                      return new Future.error(90);
-                                    });
+    SendPort p = singleCompletePort(completer, callback: (v) {
+      expect(42, v);
+      return new Future.error(90);
+    });
     p.send(42);
     return completer.future.then((v) {
       fail("unreachable");
     }, onError: (e, s) {
       expect(e, 90);
     });
   });
 
   test("singleCompleteFirstValue", () {
     Completer completer = new Completer.sync();
     SendPort p = singleCompletePort(completer);
     p.send(42);
     p.send(37);
     return completer.future.then((v) {
       expect(v, 42);
     });
   });
 
   test("singleCompleteFirstValueCallback", () {
     Completer completer = new Completer.sync();
     SendPort p = singleCompletePort(completer, callback: (v) {
-                                                 expect(v, 42);
-                                                 return 87;
-                                               });
+      expect(v, 42);
+      return 87;
+    });
     p.send(42);
     p.send(37);
     return completer.future.then((v) {
       expect(v, 87);
     });
   });
 
   test("singleCompleteValueBeforeTimeout", () {
     Completer completer = new Completer.sync();
-    SendPort p = singleCompletePort(completer,
-                                    timeout: MS * 500);
+    SendPort p = singleCompletePort(completer, timeout: MS * 500);
     p.send(42);
     return completer.future.then((v) {
       expect(v, 42);
     });
   });
 
   test("singleCompleteTimeout", () {
     Completer completer = new Completer.sync();
-    singleCompletePort(completer,
-                       timeout: MS * 100);
+    singleCompletePort(completer, timeout: MS * 100);
     return completer.future.then((v) {
       fail("unreachable");
     }, onError: (e, s) {
       expect(e is TimeoutException, isTrue);
     });
   });
 
   test("singleCompleteTimeoutCallback", () {
     Completer completer = new Completer.sync();
-    singleCompletePort(completer,
-                       timeout: MS * 100,
-                       onTimeout: () => 87);
+    singleCompletePort(completer, timeout: MS * 100, onTimeout: () => 87);
     return completer.future.then((v) {
       expect(v, 87);
     });
   });
 
   test("singleCompleteTimeoutCallbackThrows", () {
     Completer completer = new Completer.sync();
-    singleCompletePort(completer,
-                       timeout: MS * 100,
-                       onTimeout: () => throw 91);
+    singleCompletePort(completer, timeout: MS * 100, onTimeout: () => throw 91);
     return completer.future.then((v) {
       fail("unreachable");
     }, onError: (e, s) {
       expect(e, 91);
     });
   });
 
   test("singleCompleteTimeoutCallbackFuture", () {
     Completer completer = new Completer.sync();
     singleCompletePort(completer,
-                       timeout: MS * 100,
-                       onTimeout: () => new Future.value(87));
+        timeout: MS * 100, onTimeout: () => new Future.value(87));
     return completer.future.then((v) {
       expect(v, 87);
     });
   });
 
   test("singleCompleteTimeoutCallbackThrowsFuture", () {
     Completer completer = new Completer.sync();
     singleCompletePort(completer,
-                       timeout: MS * 100,
-                       onTimeout: () => new Future.error(92));
+        timeout: MS * 100, onTimeout: () => new Future.error(92));
     return completer.future.then((v) {
       fail("unreachable");
     }, onError: (e, s) {
       expect(e, 92);
     });
   });
 
   test("singleCompleteTimeoutCallbackSLow", () {
     Completer completer = new Completer.sync();
-    singleCompletePort(
-        completer,
+    singleCompletePort(completer,
         timeout: MS * 100,
         onTimeout: () => new Future.delayed(MS * 500, () => 87));
     return completer.future.then((v) {
       expect(v, 87);
     });
   });
 
   test("singleCompleteTimeoutCallbackThrowsSlow", () {
     Completer completer = new Completer.sync();
-    singleCompletePort(
-        completer,
+    singleCompletePort(completer,
         timeout: MS * 100,
         onTimeout: () => new Future.delayed(MS * 500, () => throw 87));
     return completer.future.then((v) {
       fail("unreachable");
     }, onError: (e, s) {
       expect(e, 87);
     });
   });
 
   test("singleCompleteTimeoutFirst", () {
     Completer completer = new Completer.sync();
-    SendPort p = singleCompletePort(completer,
-                                    timeout: MS * 100,
-                                    onTimeout: () => 37);
+    SendPort p =
+        singleCompletePort(completer, timeout: MS * 100, onTimeout: () => 37);
     new Timer(MS * 500, () => p.send(42));
     return completer.future.then((v) {
       expect(v, 37);
     });
   });
 }
 
 void testSingleResponseFuture() {
   test("singleResponseFutureValue", () {
     return singleResponseFuture((SendPort p) {
@@ skipping 109 matching lines @@
   test("singleResultFutureTimeoutError", () {
     return singleResultFuture((SendPort p) {
       // no-op.
     }, timeout: MS * 100, onTimeout: () => throw 97).then((v) {
       expect(v, 42);
     }, onError: (e, s) {
       expect(e, 97);
     });
   });
 }