OLD | NEW |
(Empty) | |
| 1 // Copyright (c) 2015, the Dart project authors. Please see the AUTHORS file |
| 2 // for details. All rights reserved. Use of this source code is governed by a |
| 3 // BSD-style license that can be found in the LICENSE file. |
| 4 |
| 5 import 'dart:async'; |
| 6 |
| 7 import 'package:async/async.dart'; |
| 8 import 'package:test/test.dart'; |
| 9 |
| 10 import 'utils.dart'; |
| 11 |
| 12 void main() { |
| 13 group("without being canceled", () { |
| 14 var completer; |
| 15 setUp(() { |
| 16 completer = new CancelableCompleter( |
| 17 onCancel: expectAsync(() {}, count: 0)); |
| 18 }); |
| 19 |
| 20 test("sends values to the future", () { |
| 21 expect(completer.operation.value, completion(equals(1))); |
| 22 expect(completer.isCompleted, isFalse); |
| 23 completer.complete(1); |
| 24 expect(completer.isCompleted, isTrue); |
| 25 }); |
| 26 |
| 27 test("sends errors to the future", () { |
| 28 expect(completer.operation.value, throwsA("error")); |
| 29 expect(completer.isCompleted, isFalse); |
| 30 completer.completeError("error"); |
| 31 expect(completer.isCompleted, isTrue); |
| 32 }); |
| 33 |
| 34 test("sends values in a future to the future", () { |
| 35 expect(completer.operation.value, completion(equals(1))); |
| 36 expect(completer.isCompleted, isFalse); |
| 37 completer.complete(new Future.value(1)); |
| 38 expect(completer.isCompleted, isTrue); |
| 39 }); |
| 40 |
| 41 test("sends errors in a future to the future", () { |
| 42 expect(completer.operation.value, throwsA("error")); |
| 43 expect(completer.isCompleted, isFalse); |
| 44 completer.complete(new Future.error("error")); |
| 45 expect(completer.isCompleted, isTrue); |
| 46 }); |
| 47 |
| 48 group("throws a StateError if completed", () { |
| 49 test("successfully twice", () { |
| 50 completer.complete(1); |
| 51 expect(() => completer.complete(1), throwsStateError); |
| 52 }); |
| 53 |
| 54 test("successfully then unsuccessfully", () { |
| 55 completer.complete(1); |
| 56 expect(() => completer.completeError("error"), throwsStateError); |
| 57 }); |
| 58 |
| 59 test("unsuccessfully twice", () { |
| 60 expect(completer.operation.value, throwsA("error")); |
| 61 completer.completeError("error"); |
| 62 expect(() => completer.completeError("error"), throwsStateError); |
| 63 }); |
| 64 |
| 65 test("successfully then with a future", () { |
| 66 completer.complete(1); |
| 67 expect(() => completer.complete(new Completer().future), |
| 68 throwsStateError); |
| 69 }); |
| 70 |
| 71 test("with a future then successfully", () { |
| 72 completer.complete(new Completer().future); |
| 73 expect(() => completer.complete(1), throwsStateError); |
| 74 }); |
| 75 |
| 76 test("with a future twice", () { |
| 77 completer.complete(new Completer().future); |
| 78 expect(() => completer.complete(new Completer().future), |
| 79 throwsStateError); |
| 80 }); |
| 81 }); |
| 82 |
| 83 group("CancelableOperation.fromFuture", () { |
| 84 test("forwards values", () { |
| 85 var operation = new CancelableOperation.fromFuture(new Future.value(1)); |
| 86 expect(operation.value, completion(equals(1))); |
| 87 }); |
| 88 |
| 89 test("forwards errors", () { |
| 90 var operation = new CancelableOperation.fromFuture( |
| 91 new Future.error("error")); |
| 92 expect(operation.value, throwsA("error")); |
| 93 }); |
| 94 }); |
| 95 }); |
| 96 |
| 97 group("when canceled", () { |
| 98 test("causes the future never to fire", () async { |
| 99 var completer = new CancelableCompleter(); |
| 100 completer.operation.value.whenComplete(expectAsync(() {}, count: 0)); |
| 101 completer.operation.cancel(); |
| 102 |
| 103 // Give the future plenty of time to fire if it's going to. |
| 104 await flushMicrotasks(); |
| 105 completer.complete(); |
| 106 await flushMicrotasks(); |
| 107 }); |
| 108 |
| 109 test("fires onCancel", () { |
| 110 var canceled = false; |
| 111 var completer; |
| 112 completer = new CancelableCompleter(onCancel: expectAsync(() { |
| 113 expect(completer.isCanceled, isTrue); |
| 114 canceled = true; |
| 115 })); |
| 116 |
| 117 expect(canceled, isFalse); |
| 118 expect(completer.isCanceled, isFalse); |
| 119 expect(completer.isCompleted, isFalse); |
| 120 completer.operation.cancel(); |
| 121 expect(canceled, isTrue); |
| 122 expect(completer.isCanceled, isTrue); |
| 123 expect(completer.isCompleted, isFalse); |
| 124 }); |
| 125 |
| 126 test("returns the onCancel future each time cancel is called", () { |
| 127 var completer = new CancelableCompleter(onCancel: expectAsync(() { |
| 128 return new Future.value(1); |
| 129 })); |
| 130 expect(completer.operation.cancel(), completion(equals(1))); |
| 131 expect(completer.operation.cancel(), completion(equals(1))); |
| 132 expect(completer.operation.cancel(), completion(equals(1))); |
| 133 }); |
| 134 |
| 135 test("returns a future even if onCancel doesn't", () { |
| 136 var completer = new CancelableCompleter(onCancel: expectAsync(() {})); |
| 137 expect(completer.operation.cancel(), completes); |
| 138 }); |
| 139 |
| 140 test("doesn't call onCancel if the completer has completed", () { |
| 141 var completer = new CancelableCompleter( |
| 142 onCancel: expectAsync(() {}, count: 0)); |
| 143 completer.complete(1); |
| 144 expect(completer.operation.value, completion(equals(1))); |
| 145 expect(completer.operation.cancel(), completes); |
| 146 }); |
| 147 |
| 148 test("does call onCancel if the completer has completed to an unfired " |
| 149 "Future", () { |
| 150 var completer = new CancelableCompleter(onCancel: expectAsync(() {})); |
| 151 completer.complete(new Completer().future); |
| 152 expect(completer.operation.cancel(), completes); |
| 153 }); |
| 154 |
| 155 test("doesn't call onCancel if the completer has completed to a fired " |
| 156 "Future", () async { |
| 157 var completer = new CancelableCompleter( |
| 158 onCancel: expectAsync(() {}, count: 0)); |
| 159 completer.complete(new Future.value(1)); |
| 160 await completer.operation.value; |
| 161 expect(completer.operation.cancel(), completes); |
| 162 }); |
| 163 |
| 164 test("can be completed once after being canceled", () async { |
| 165 var completer = new CancelableCompleter(); |
| 166 completer.operation.value.whenComplete(expectAsync(() {}, count: 0)); |
| 167 await completer.operation.cancel(); |
| 168 completer.complete(1); |
| 169 expect(() => completer.complete(1), throwsStateError); |
| 170 }); |
| 171 }); |
| 172 |
| 173 group("asStream()", () { |
| 174 test("emits a value and then closes", () { |
| 175 var completer = new CancelableCompleter(); |
| 176 expect(completer.operation.asStream().toList(), completion(equals([1]))); |
| 177 completer.complete(1); |
| 178 }); |
| 179 |
| 180 test("emits an error and then closes", () { |
| 181 var completer = new CancelableCompleter(); |
| 182 var queue = new StreamQueue(completer.operation.asStream()); |
| 183 expect(queue.next, throwsA("error")); |
| 184 expect(queue.hasNext, completion(isFalse)); |
| 185 completer.completeError("error"); |
| 186 }); |
| 187 |
| 188 test("cancels the completer when the subscription is canceled", () { |
| 189 var completer = new CancelableCompleter(onCancel: expectAsync(() {})); |
| 190 var sub = completer.operation.asStream() |
| 191 .listen(expectAsync((_) {}, count: 0)); |
| 192 completer.operation.value.whenComplete(expectAsync(() {}, count: 0)); |
| 193 sub.cancel(); |
| 194 expect(completer.isCanceled, isTrue); |
| 195 }); |
| 196 }); |
| 197 } |
OLD | NEW |