Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(98)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: packages/isolate/test/ports_test.dart

Issue 2990843002: Removed fixed dependencies (Closed)
Patch Set: Created 3 years, 5 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « packages/isolate/test/isolaterunner_test.dart ('k') | packages/isolate/test/registry_test.dart » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: packages/isolate/test/ports_test.dart
diff --git a/packages/isolate/test/ports_test.dart b/packages/isolate/test/ports_test.dart
new file mode 100644
index 0000000000000000000000000000000000000000..322b540d2056d7c16f0f922152e46bea74825217
--- /dev/null
+++ b/packages/isolate/test/ports_test.dart
@@ -0,0 +1,517 @@
+// 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 isolate.test.ports_test;
+
+import 'dart:async';
+import 'dart:isolate';
+
+import 'package:isolate/ports.dart';
+import 'package:test/test.dart';
+
+const Duration MS = const Duration(milliseconds: 1);
+
+main() {
+ group('SingleCallbackPort', testSingleCallbackPort);
+ group('SingleCompletePort', testSingleCompletePort);
+ group('SingleResponseFuture', testSingleResponseFuture);
+ group('SingleResponseFuture', testSingleResultFuture);
+ group('SingleResponseChannel', testSingleResponseChannel);
+}
+
+void testSingleCallbackPort() {
+ test("Value", () {
+ Completer completer = new Completer.sync();
+ SendPort p = singleCallbackPort(completer.complete);
+ p.send(42);
+ return completer.future.then((v) {
+ expect(v, 42);
+ });
+ });
+
+ test("FirstValue", () {
+ 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("Value", () {
+ Completer completer = new Completer.sync();
+ SendPort p = singleCallbackPort(completer.complete);
+ p.send(42);
+ return completer.future.then((v) {
+ expect(v, 42);
+ });
+ });
+
+ test("ValueBeforeTimeout", () {
+ 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("Timeout", () {
+ Completer completer = new Completer.sync();
+ singleCallbackPort(completer.complete, timeout: MS * 100, timeoutValue: 37);
+ return completer.future.then((v) {
+ expect(v, 37);
+ });
+ });
+
+ test("TimeoutFirst", () {
+ 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("Value", () {
+ Completer completer = new Completer.sync();
+ SendPort p = singleCompletePort(completer);
+ p.send(42);
+ return completer.future.then((v) {
+ expect(v, 42);
+ });
+ });
+
+ test("ValueCallback", () {
+ 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("ValueCallbackFuture", () {
+ 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("ValueCallbackThrows", () {
+ 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("ValueCallbackThrowsFuture", () {
+ 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("FirstValue", () {
+ Completer completer = new Completer.sync();
+ SendPort p = singleCompletePort(completer);
+ p.send(42);
+ p.send(37);
+ return completer.future.then((v) {
+ expect(v, 42);
+ });
+ });
+
+ test("FirstValueCallback", () {
+ 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("ValueBeforeTimeout", () {
+ Completer completer = new Completer.sync();
+ SendPort p = singleCompletePort(completer, timeout: MS * 500);
+ p.send(42);
+ return completer.future.then((v) {
+ expect(v, 42);
+ });
+ });
+
+ test("Timeout", () {
+ 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("TimeoutCallback", () {
+ Completer completer = new Completer.sync();
+ singleCompletePort(completer, timeout: MS * 100, onTimeout: () => 87);
+ return completer.future.then((v) {
+ expect(v, 87);
+ });
+ });
+
+ test("TimeoutCallbackThrows", () {
+ 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("TimeoutCallbackFuture", () {
+ Completer completer = new Completer.sync();
+ singleCompletePort(completer,
+ timeout: MS * 100,
+ onTimeout: () => new Future.value(87));
+ return completer.future.then((v) {
+ expect(v, 87);
+ });
+ });
+
+ test("TimeoutCallbackThrowsFuture", () {
+ 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("TimeoutCallbackSLow", () {
+ 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("TimeoutCallbackThrowsSlow", () {
+ 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("TimeoutFirst", () {
+ 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("FutureValue", () {
+ return singleResponseFuture((SendPort p) {
+ p.send(42);
+ }).then((v) {
+ expect(v, 42);
+ });
+ });
+
+ test("FutureValueFirst", () {
+ return singleResponseFuture((SendPort p) {
+ p.send(42);
+ p.send(37);
+ }).then((v) {
+ expect(v, 42);
+ });
+ });
+
+ test("FutureError", () {
+ return singleResponseFuture((SendPort p) {
+ throw 93;
+ }).then((v) {
+ fail("unreachable");
+ }, onError: (e, s) {
+ expect(e, 93);
+ });
+ });
+
+ test("FutureTimeout", () {
+ return singleResponseFuture((SendPort p) {
+ // no-op.
+ }, timeout: MS * 100).then((v) {
+ expect(v, null);
+ });
+ });
+
+ test("FutureTimeoutValue", () {
+ return singleResponseFuture((SendPort p) {
+ // no-op.
+ }, timeout: MS * 100, timeoutValue: 42).then((v) {
+ expect(v, 42);
+ });
+ });
+}
+
+void testSingleResultFuture() {
+ test("Value", () {
+ return singleResultFuture((SendPort p) {
+ sendFutureResult(new Future.value(42), p);
+ }).then((v) {
+ expect(v, 42);
+ });
+ });
+
+ test("ValueFirst", () {
+ return singleResultFuture((SendPort p) {
+ sendFutureResult(new Future.value(42), p);
+ sendFutureResult(new Future.value(37), p);
+ }).then((v) {
+ expect(v, 42);
+ });
+ });
+
+ test("Error", () {
+ return singleResultFuture((SendPort p) {
+ sendFutureResult(new Future.error(94), p);
+ }).then((v) {
+ fail("unreachable");
+ }, onError: (e, s) {
+ expect(e is RemoteError, isTrue);
+ });
+ });
+
+ test("ErrorFirst", () {
+ 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("Error", () {
+ return singleResultFuture((SendPort p) {
+ throw 93;
+ }).then((v) {
+ fail("unreachable");
+ }, onError: (e, s) {
+ expect(e is RemoteError, isTrue);
+ });
+ });
+
+ test("Timeout", () {
+ return singleResultFuture((SendPort p) {
+ // no-op.
+ }, timeout: MS * 100).then((v) {
+ fail("unreachable");
+ }, onError: (e, s) {
+ expect(e is TimeoutException, isTrue);
+ });
+ });
+
+ test("TimeoutValue", () {
+ return singleResultFuture((SendPort p) {
+ // no-op.
+ }, timeout: MS * 100, onTimeout: () => 42).then((v) {
+ expect(v, 42);
+ });
+ });
+
+ test("TimeoutError", () {
+ return singleResultFuture((SendPort p) {
+ // no-op.
+ }, timeout: MS * 100, onTimeout: () => throw 97).then((v) {
+ expect(v, 42);
+ }, onError: (e, s) {
+ expect(e, 97);
+ });
+ });
+}
+
+void testSingleResponseChannel() {
+ test("Value", () {
+ var channel = new SingleResponseChannel();
+ channel.port.send(42);
+ return channel.result.then((v) {
+ expect(v, 42);
+ });
+ });
+
+ test("ValueFirst", () {
+ var channel = new SingleResponseChannel();
+ channel.port.send(42);
+ channel.port.send(37);
+ return channel.result.then((v) {
+ expect(v, 42);
+ });
+ });
+
+ test("ValueCallback", () {
+ var channel = new SingleResponseChannel(callback: (v) => v * 2);
+ channel.port.send(42);
+ return channel.result.then((v) {
+ expect(v, 84);
+ });
+ });
+
+ test("ErrorCallback", () {
+ var channel = new SingleResponseChannel(callback: (v) => throw 42);
+ channel.port.send(37);
+ return channel.result.then((v) { fail("unreachable"); },
+ onError: (v, s) {
+ expect(v, 42);
+ });
+ });
+
+ test("AsyncValueCallback", () {
+ var channel = new SingleResponseChannel(
+ callback: (v) => new Future.value(v * 2));
+ channel.port.send(42);
+ return channel.result.then((v) {
+ expect(v, 84);
+ });
+ });
+
+ test("AsyncErrorCallback", () {
+ var channel = new SingleResponseChannel(callback:
+ (v) => new Future.error(42));
+ channel.port.send(37);
+ return channel.result.then((v) { fail("unreachable"); },
+ onError: (v, s) {
+ expect(v, 42);
+ });
+ });
+
+ test("Timeout", () {
+ var channel = new SingleResponseChannel(timeout: MS * 100);
+ return channel.result.then((v) {
+ expect(v, null);
+ });
+ });
+
+ test("TimeoutThrow", () {
+ var channel = new SingleResponseChannel(timeout: MS * 100,
+ throwOnTimeout: true);
+ return channel.result.then((v) { fail("unreachable"); },
+ onError: (v, s) {
+ expect(v is TimeoutException, isTrue);
+ });
+ });
+
+ test("TimeoutThrowOnTimeoutAndValue", () {
+ var channel = new SingleResponseChannel(timeout: MS * 100,
+ throwOnTimeout: true,
+ onTimeout: () => 42,
+ timeoutValue: 42);
+ return channel.result.then((v) { fail("unreachable"); },
+ onError: (v, s) {
+ expect(v is TimeoutException, isTrue);
+ });
+ });
+
+ test("TimeoutOnTimeout", () {
+ var channel = new SingleResponseChannel(timeout: MS * 100,
+ onTimeout: () => 42);
+ return channel.result.then((v) {
+ expect(v, 42);
+ });
+ });
+
+ test("TimeoutOnTimeoutAndValue", () {
+ var channel = new SingleResponseChannel(timeout: MS * 100,
+ onTimeout: () => 42,
+ timeoutValue: 37);
+ return channel.result.then((v) {
+ expect(v, 42);
+ });
+ });
+
+ test("TimeoutValue", () {
+ var channel = new SingleResponseChannel(timeout: MS * 100,
+ timeoutValue: 42);
+ return channel.result.then((v) {
+ expect(v, 42);
+ });
+ });
+
+ test("TimeoutOnTimeoutError", () {
+ var channel = new SingleResponseChannel(timeout: MS * 100,
+ onTimeout: () => throw 42);
+ return channel.result.then((v) { fail("unreachable"); },
+ onError: (v, s) {
+ expect(v, 42);
+ });
+ });
+
+ test("TimeoutOnTimeoutAsync", () {
+ var channel = new SingleResponseChannel(timeout: MS * 100,
+ onTimeout:
+ () => new Future.value(42));
+ return channel.result.then((v) {
+ expect(v, 42);
+ });
+ });
+
+ test("TimeoutOnTimeoutAsyncError", () {
+ var channel = new SingleResponseChannel(timeout: MS * 100,
+ onTimeout:
+ () => new Future.error(42));
+ return channel.result.then((v) { fail("unreachable"); },
+ onError: (v, s) {
+ expect(v, 42);
+ });
+ });
+}
« no previous file with comments | « packages/isolate/test/isolaterunner_test.dart ('k') | packages/isolate/test/registry_test.dart » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698