| // 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. |
| |
| import 'dart:async'; |
| |
| import 'package:async/async.dart'; |
| import 'package:test/test.dart'; |
| |
| import 'utils.dart'; |
| |
| void main() { |
| group("without being canceled", () { |
| CancelableCompleter completer; |
| setUp(() { |
| completer = CancelableCompleter(onCancel: expectAsync0(() {}, count: 0)); |
| }); |
| |
| test("sends values to the future", () { |
| expect(completer.operation.value, completion(equals(1))); |
| expect(completer.isCompleted, isFalse); |
| completer.complete(1); |
| expect(completer.isCompleted, isTrue); |
| }); |
| |
| test("sends errors to the future", () { |
| expect(completer.operation.value, throwsA("error")); |
| expect(completer.isCompleted, isFalse); |
| completer.completeError("error"); |
| expect(completer.isCompleted, isTrue); |
| }); |
| |
| test("sends values in a future to the future", () { |
| expect(completer.operation.value, completion(equals(1))); |
| expect(completer.isCompleted, isFalse); |
| completer.complete(Future.value(1)); |
| expect(completer.isCompleted, isTrue); |
| }); |
| |
| test("sends errors in a future to the future", () { |
| expect(completer.operation.value, throwsA("error")); |
| expect(completer.isCompleted, isFalse); |
| expect(completer.operation.isCompleted, isFalse); |
| completer.complete(Future.error("error")); |
| expect(completer.isCompleted, isTrue); |
| expect(completer.operation.isCompleted, isTrue); |
| }); |
| |
| test("sends values to valueOrCancellation", () { |
| expect(completer.operation.valueOrCancellation(), completion(equals(1))); |
| completer.complete(1); |
| }); |
| |
| test("sends errors to valueOrCancellation", () { |
| expect(completer.operation.valueOrCancellation(), throwsA("error")); |
| completer.completeError("error"); |
| }); |
| |
| group("throws a StateError if completed", () { |
| test("successfully twice", () { |
| completer.complete(1); |
| expect(() => completer.complete(1), throwsStateError); |
| }); |
| |
| test("successfully then unsuccessfully", () { |
| completer.complete(1); |
| expect(() => completer.completeError("error"), throwsStateError); |
| }); |
| |
| test("unsuccessfully twice", () { |
| expect(completer.operation.value, throwsA("error")); |
| completer.completeError("error"); |
| expect(() => completer.completeError("error"), throwsStateError); |
| }); |
| |
| test("successfully then with a future", () { |
| completer.complete(1); |
| expect(() => completer.complete(Completer().future), throwsStateError); |
| }); |
| |
| test("with a future then successfully", () { |
| completer.complete(Completer().future); |
| expect(() => completer.complete(1), throwsStateError); |
| }); |
| |
| test("with a future twice", () { |
| completer.complete(Completer().future); |
| expect(() => completer.complete(Completer().future), throwsStateError); |
| }); |
| }); |
| |
| group("CancelableOperation.fromFuture", () { |
| test("forwards values", () { |
| var operation = CancelableOperation.fromFuture(Future.value(1)); |
| expect(operation.value, completion(equals(1))); |
| }); |
| |
| test("forwards errors", () { |
| var operation = CancelableOperation.fromFuture(Future.error("error")); |
| expect(operation.value, throwsA("error")); |
| }); |
| }); |
| }); |
| |
| group("when canceled", () { |
| test("causes the future never to fire", () async { |
| var completer = CancelableCompleter(); |
| completer.operation.value.whenComplete(expectAsync0(() {}, count: 0)); |
| completer.operation.cancel(); |
| |
| // Give the future plenty of time to fire if it's going to. |
| await flushMicrotasks(); |
| completer.complete(); |
| await flushMicrotasks(); |
| }); |
| |
| test("fires onCancel", () { |
| var canceled = false; |
| CancelableCompleter completer; |
| completer = CancelableCompleter(onCancel: expectAsync0(() { |
| expect(completer.isCanceled, isTrue); |
| canceled = true; |
| })); |
| |
| expect(canceled, isFalse); |
| expect(completer.isCanceled, isFalse); |
| expect(completer.operation.isCanceled, isFalse); |
| expect(completer.isCompleted, isFalse); |
| expect(completer.operation.isCompleted, isFalse); |
| completer.operation.cancel(); |
| expect(canceled, isTrue); |
| expect(completer.isCanceled, isTrue); |
| expect(completer.operation.isCanceled, isTrue); |
| expect(completer.isCompleted, isFalse); |
| expect(completer.operation.isCompleted, isFalse); |
| }); |
| |
| test("returns the onCancel future each time cancel is called", () { |
| var completer = CancelableCompleter(onCancel: expectAsync0(() { |
| return Future.value(1); |
| })); |
| expect(completer.operation.cancel(), completion(equals(1))); |
| expect(completer.operation.cancel(), completion(equals(1))); |
| expect(completer.operation.cancel(), completion(equals(1))); |
| }); |
| |
| test("returns a future even if onCancel doesn't", () { |
| var completer = CancelableCompleter(onCancel: expectAsync0(() {})); |
| expect(completer.operation.cancel(), completes); |
| }); |
| |
| test("doesn't call onCancel if the completer has completed", () { |
| var completer = |
| CancelableCompleter(onCancel: expectAsync0(() {}, count: 0)); |
| completer.complete(1); |
| expect(completer.operation.value, completion(equals(1))); |
| expect(completer.operation.cancel(), completes); |
| }); |
| |
| test( |
| "does call onCancel if the completer has completed to an unfired " |
| "Future", () { |
| var completer = CancelableCompleter(onCancel: expectAsync0(() {})); |
| completer.complete(Completer().future); |
| expect(completer.operation.cancel(), completes); |
| }); |
| |
| test( |
| "doesn't call onCancel if the completer has completed to a fired " |
| "Future", () async { |
| var completer = |
| CancelableCompleter(onCancel: expectAsync0(() {}, count: 0)); |
| completer.complete(Future.value(1)); |
| await completer.operation.value; |
| expect(completer.operation.cancel(), completes); |
| }); |
| |
| test("can be completed once after being canceled", () async { |
| var completer = CancelableCompleter(); |
| completer.operation.value.whenComplete(expectAsync0(() {}, count: 0)); |
| await completer.operation.cancel(); |
| completer.complete(1); |
| expect(() => completer.complete(1), throwsStateError); |
| }); |
| |
| test("fires valueOrCancellation with the given value", () { |
| var completer = CancelableCompleter(); |
| expect(completer.operation.valueOrCancellation(1), completion(equals(1))); |
| completer.operation.cancel(); |
| }); |
| |
| test("pipes an error through valueOrCancellation", () { |
| var completer = CancelableCompleter(onCancel: () { |
| throw "error"; |
| }); |
| expect(completer.operation.valueOrCancellation(1), throwsA("error")); |
| completer.operation.cancel(); |
| }); |
| |
| test("valueOrCancellation waits on the onCancel future", () async { |
| var innerCompleter = Completer(); |
| var completer = |
| CancelableCompleter(onCancel: () => innerCompleter.future); |
| |
| var fired = false; |
| completer.operation.valueOrCancellation().then((_) { |
| fired = true; |
| }); |
| |
| completer.operation.cancel(); |
| await flushMicrotasks(); |
| expect(fired, isFalse); |
| |
| innerCompleter.complete(); |
| await flushMicrotasks(); |
| expect(fired, isTrue); |
| }); |
| }); |
| |
| group("asStream()", () { |
| test("emits a value and then closes", () { |
| var completer = CancelableCompleter(); |
| expect(completer.operation.asStream().toList(), completion(equals([1]))); |
| completer.complete(1); |
| }); |
| |
| test("emits an error and then closes", () { |
| var completer = CancelableCompleter(); |
| var queue = StreamQueue(completer.operation.asStream()); |
| expect(queue.next, throwsA("error")); |
| expect(queue.hasNext, completion(isFalse)); |
| completer.completeError("error"); |
| }); |
| |
| test("cancels the completer when the subscription is canceled", () { |
| var completer = CancelableCompleter(onCancel: expectAsync0(() {})); |
| var sub = |
| completer.operation.asStream().listen(expectAsync1((_) {}, count: 0)); |
| completer.operation.value.whenComplete(expectAsync0(() {}, count: 0)); |
| sub.cancel(); |
| expect(completer.isCanceled, isTrue); |
| }); |
| }); |
| |
| group("then", () { |
| FutureOr<String> Function(int) onValue; |
| FutureOr<String> Function(Object, StackTrace) onError; |
| FutureOr<String> Function() onCancel; |
| bool propagateCancel; |
| CancelableCompleter<int> originalCompleter; |
| |
| setUp(() { |
| // Initialize all functions to ones that expect to not be called. |
| onValue = expectAsync1((_) => null, count: 0, id: "onValue"); |
| onError = expectAsync2((e, s) => null, count: 0, id: "onError"); |
| onCancel = expectAsync0(() => null, count: 0, id: "onCancel"); |
| propagateCancel = false; |
| }); |
| |
| CancelableOperation<String> runThen() { |
| originalCompleter = CancelableCompleter(); |
| return originalCompleter.operation.then(onValue, |
| onError: onError, |
| onCancel: onCancel, |
| propagateCancel: propagateCancel); |
| } |
| |
| group("original operation completes successfully", () { |
| test("onValue completes successfully", () { |
| onValue = expectAsync1((v) => v.toString(), count: 1, id: "onValue"); |
| |
| expect(runThen().value, completion("1")); |
| originalCompleter.complete(1); |
| }); |
| |
| test("onValue throws error", () { |
| // expectAsync1 only works with functions that do not throw. |
| onValue = (_) => throw "error"; |
| |
| expect(runThen().value, throwsA("error")); |
| originalCompleter.complete(1); |
| }); |
| |
| test("onValue returns Future that throws error", () { |
| onValue = |
| expectAsync1((v) => Future.error("error"), count: 1, id: "onValue"); |
| |
| expect(runThen().value, throwsA("error")); |
| originalCompleter.complete(1); |
| }); |
| |
| test("and returned operation is canceled with propagateCancel = false", |
| () async { |
| propagateCancel = false; |
| |
| runThen().cancel(); |
| |
| // onValue should not be called. |
| originalCompleter.complete(1); |
| }); |
| }); |
| |
| group("original operation completes with error", () { |
| test("onError not set", () { |
| onError = null; |
| |
| expect(runThen().value, throwsA("error")); |
| originalCompleter.completeError("error"); |
| }); |
| |
| test("onError completes successfully", () { |
| onError = expectAsync2((e, s) => "onError caught $e", |
| count: 1, id: "onError"); |
| |
| expect(runThen().value, completion("onError caught error")); |
| originalCompleter.completeError("error"); |
| }); |
| |
| test("onError throws", () { |
| // expectAsync2 does not work with functions that throw. |
| onError = (e, s) => throw "onError caught $e"; |
| |
| expect(runThen().value, throwsA("onError caught error")); |
| originalCompleter.completeError("error"); |
| }); |
| |
| test("onError returns Future that throws", () { |
| onError = expectAsync2((e, s) => Future.error("onError caught $e"), |
| count: 1, id: "onError"); |
| |
| expect(runThen().value, throwsA("onError caught error")); |
| originalCompleter.completeError("error"); |
| }); |
| |
| test("and returned operation is canceled with propagateCancel = false", |
| () async { |
| propagateCancel = false; |
| |
| runThen().cancel(); |
| |
| // onError should not be called. |
| originalCompleter.completeError("error"); |
| }); |
| }); |
| |
| group("original operation canceled", () { |
| test("onCancel not set", () { |
| onCancel = null; |
| |
| final operation = runThen(); |
| |
| expect(originalCompleter.operation.cancel(), completes); |
| expect(operation.isCanceled, true); |
| }); |
| |
| test("onCancel completes successfully", () { |
| onCancel = expectAsync0(() => "canceled", count: 1, id: "onCancel"); |
| |
| expect(runThen().value, completion("canceled")); |
| originalCompleter.operation.cancel(); |
| }); |
| |
| test("onCancel throws error", () { |
| // expectAsync0 only works with functions that do not throw. |
| onCancel = () => throw "error"; |
| |
| expect(runThen().value, throwsA("error")); |
| originalCompleter.operation.cancel(); |
| }); |
| |
| test("onCancel returns Future that throws error", () { |
| onCancel = |
| expectAsync0(() => Future.error("error"), count: 1, id: "onCancel"); |
| |
| expect(runThen().value, throwsA("error")); |
| originalCompleter.operation.cancel(); |
| }); |
| }); |
| |
| group("returned operation canceled", () { |
| test("propagateCancel is true", () async { |
| propagateCancel = true; |
| |
| await runThen().cancel(); |
| |
| expect(originalCompleter.isCanceled, true); |
| }); |
| |
| test("propagateCancel is false", () async { |
| propagateCancel = false; |
| |
| await runThen().cancel(); |
| |
| expect(originalCompleter.isCanceled, false); |
| }); |
| }); |
| }); |
| } |