Add IsolateRunner as a helper around Isolate.

test/ports_test.dart

Index: test/ports_test.dart
diff --git a/test/ports_test.dart b/test/ports_test.dart
new file mode 100644
index 0000000000000000000000000000000000000000..9586b96da680fb72cad877da7f9d1828eb057ac9
--- /dev/null
+++ b/test/ports_test.dart
@@ -0,0 +1,394 @@
+// 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";
+
+const Duration MS = const Duration(milliseconds: 1);
+
+main() {
+  testSingleCallbackPort();
+  testSingleCompletePort();
+  testSingleResponseFuture();
+  testSingleResultFuture();
+}
+
+void testSingleCallbackPort() {
+  test("singleCallbackValue", () {
+    Completer completer = new Completer.sync();
+    SendPort p = singleCallbackPort(completer.complete);
+    p.send(42);
+    return completer.future.then((v) {
+      expect(v, 42);
+    });
+  });
+
+  test("singleCallbackFirstValue", () {
+    Completer completer = new Completer.sync();
+    SendPort p = singleCallbackPort(completer.complete);
+    p.send(42);
+    p.send(37);
+    return completer.future.then((v) {
+      expect(v, 42);
+    });
+  });
+  test("singleCallbackValue", () {
+    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);
+    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);
+    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);
+    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;
+                                    });
+    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);
+                                    });
+    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;
+                                    });
+    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);
+                                    });
+    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;
+                                               });
+    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);
+    p.send(42);
+    return completer.future.then((v) {
+      expect(v, 42);
+    });
+  });
+
+  test("singleCompleteTimeout", () {
+    Completer completer = new Completer.sync();
+    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);
+    return completer.future.then((v) {
+      expect(v, 87);
+    });
+  });
+
+  test("singleCompleteTimeoutCallbackThrows", () {
+    Completer completer = new Completer.sync();
+    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));
+    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));
+    return completer.future.then((v) {
+      fail("unreachable");
+    }, onError: (e, s) {
+      expect(e, 92);
+    });
+  });
+
+  test("singleCompleteTimeoutCallbackSLow", () {
+    Completer completer = new Completer.sync();
+    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,
+        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);
+    new Timer(MS * 500, () => p.send(42));
+    return completer.future.then((v) {
+      expect(v, 37);
+    });
+  });
+}
+
+void testSingleResponseFuture() {
+  test("singleResponseFutureValue", () {
+    return singleResponseFuture((SendPort p) {
+      p.send(42);
+    }).then((v) {
+      expect(v, 42);
+    });
+  });
+
+  test("singleResponseFutureValueFirst", () {
+    return singleResponseFuture((SendPort p) {
+      p.send(42);
+      p.send(37);
+    }).then((v) {
+      expect(v, 42);
+    });
+  });
+
+  test("singleResponseFutureError", () {
+    return singleResponseFuture((SendPort p) {
+      throw 93;
+    }).then((v) {
+      fail("unreachable");
+    }, onError: (e, s) {
+      expect(e, 93);
+    });
+  });
+
+  test("singleResponseFutureTimeout", () {
+    return singleResponseFuture((SendPort p) {
+      // no-op.
+    }, timeout: MS * 100).then((v) {
+      expect(v, null);
+    });
+  });
+
+  test("singleResponseFutureTimeoutValue", () {
+    return singleResponseFuture((SendPort p) {
+      // no-op.
+    }, timeout: MS * 100, timeoutValue: 42).then((v) {
+      expect(v, 42);
+    });
+  });
+}
+
+void testSingleResultFuture() {
+  test("singleResultFutureValue", () {
+    return singleResultFuture((SendPort p) {
+      sendFutureResult(new Future.value(42), p);
+    }).then((v) {
+      expect(v, 42);
+    });
+  });
+
+  test("singleResultFutureValueFirst", () {
+    return singleResultFuture((SendPort p) {
+      sendFutureResult(new Future.value(42), p);
+      sendFutureResult(new Future.value(37), p);
+    }).then((v) {
+      expect(v, 42);
+    });
+  });
+
+  test("singleResultFutureError", () {
+    return singleResultFuture((SendPort p) {
+      sendFutureResult(new Future.error(94), p);
+    }).then((v) {
+      fail("unreachable");
+    }, onError: (e, s) {
+      expect(e is RemoteError, isTrue);
+    });
+  });
+
+  test("singleResultFutureErrorFirst", () {
+    return singleResultFuture((SendPort p) {
+      sendFutureResult(new Future.error(95), p);
+      sendFutureResult(new Future.error(96), p);
+    }).then((v) {
+      fail("unreachable");
+    }, onError: (e, s) {
+      expect(e is RemoteError, isTrue);
+    });
+  });
+
+  test("singleResultFutureError", () {
+    return singleResultFuture((SendPort p) {
+      throw 93;
+    }).then((v) {
+      fail("unreachable");
+    }, onError: (e, s) {
+      expect(e is RemoteError, isTrue);
+    });
+  });
+
+  test("singleResultFutureTimeout", () {
+    return singleResultFuture((SendPort p) {
+      // no-op.
+    }, timeout: MS * 100).then((v) {
+      fail("unreachable");
+    }, onError: (e, s) {
+      expect(e is TimeoutException, isTrue);
+    });
+  });
+
+  test("singleResultFutureTimeoutValue", () {
+    return singleResultFuture((SendPort p) {
+      // no-op.
+    }, timeout: MS * 100, onTimeout: () => 42).then((v) {
+      expect(v, 42);
+    });
+  });
+
+  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);
+    });
+  });
+}