OLD | NEW |
(Empty) | |
| 1 // Copyright (c) 2016, 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("with no callbacks", () { |
| 14 test("forwards cancellation", () async { |
| 15 var isCanceled = false; |
| 16 var cancelCompleter = new Completer(); |
| 17 var controller = new StreamController(onCancel: expectAsync0(() { |
| 18 isCanceled = true; |
| 19 return cancelCompleter.future; |
| 20 })); |
| 21 var subscription = controller.stream |
| 22 .transform(subscriptionTransformer()) |
| 23 .listen(expectAsync1((_) {}, count: 0)); |
| 24 |
| 25 var cancelFired = false; |
| 26 subscription.cancel().then(expectAsync1((_) { |
| 27 cancelFired = true; |
| 28 })); |
| 29 |
| 30 await flushMicrotasks(); |
| 31 expect(isCanceled, isTrue); |
| 32 expect(cancelFired, isFalse); |
| 33 |
| 34 cancelCompleter.complete(); |
| 35 await flushMicrotasks(); |
| 36 expect(cancelFired, isTrue); |
| 37 |
| 38 // This shouldn't call the onCancel callback again. |
| 39 expect(subscription.cancel(), completes); |
| 40 }); |
| 41 |
| 42 test("forwards pausing and resuming", () async { |
| 43 var controller = new StreamController(); |
| 44 var subscription = controller.stream |
| 45 .transform(subscriptionTransformer()) |
| 46 .listen(expectAsync1((_) {}, count: 0)); |
| 47 |
| 48 subscription.pause(); |
| 49 await flushMicrotasks(); |
| 50 expect(controller.isPaused, isTrue); |
| 51 |
| 52 subscription.pause(); |
| 53 await flushMicrotasks(); |
| 54 expect(controller.isPaused, isTrue); |
| 55 |
| 56 subscription.resume(); |
| 57 await flushMicrotasks(); |
| 58 expect(controller.isPaused, isTrue); |
| 59 |
| 60 subscription.resume(); |
| 61 await flushMicrotasks(); |
| 62 expect(controller.isPaused, isFalse); |
| 63 }); |
| 64 |
| 65 test("forwards pausing with a resume future", () async { |
| 66 var controller = new StreamController(); |
| 67 var subscription = controller.stream |
| 68 .transform(subscriptionTransformer()) |
| 69 .listen(expectAsync1((_) {}, count: 0)); |
| 70 |
| 71 var completer = new Completer(); |
| 72 subscription.pause(completer.future); |
| 73 await flushMicrotasks(); |
| 74 expect(controller.isPaused, isTrue); |
| 75 |
| 76 completer.complete(); |
| 77 await flushMicrotasks(); |
| 78 expect(controller.isPaused, isFalse); |
| 79 }); |
| 80 }); |
| 81 |
| 82 group("with a cancel callback", () { |
| 83 test("invokes the callback when the subscription is canceled", () async { |
| 84 var isCanceled = false; |
| 85 var callbackInvoked = false; |
| 86 var controller = new StreamController(onCancel: expectAsync0(() { |
| 87 isCanceled = true; |
| 88 })); |
| 89 var subscription = controller.stream.transform( |
| 90 subscriptionTransformer(handleCancel: expectAsync1((inner) { |
| 91 callbackInvoked = true; |
| 92 inner.cancel(); |
| 93 }))).listen(expectAsync1((_) {}, count: 0)); |
| 94 |
| 95 await flushMicrotasks(); |
| 96 expect(callbackInvoked, isFalse); |
| 97 expect(isCanceled, isFalse); |
| 98 |
| 99 subscription.cancel(); |
| 100 await flushMicrotasks(); |
| 101 expect(callbackInvoked, isTrue); |
| 102 expect(isCanceled, isTrue); |
| 103 }); |
| 104 |
| 105 test("invokes the callback once and caches its result", () async { |
| 106 var completer = new Completer(); |
| 107 var controller = new StreamController(); |
| 108 var subscription = controller.stream |
| 109 .transform(subscriptionTransformer( |
| 110 handleCancel: expectAsync1((inner) => completer.future))) |
| 111 .listen(expectAsync1((_) {}, count: 0)); |
| 112 |
| 113 var cancelFired1 = false; |
| 114 subscription.cancel().then(expectAsync1((_) { |
| 115 cancelFired1 = true; |
| 116 })); |
| 117 |
| 118 var cancelFired2 = false; |
| 119 subscription.cancel().then(expectAsync1((_) { |
| 120 cancelFired2 = true; |
| 121 })); |
| 122 |
| 123 await flushMicrotasks(); |
| 124 expect(cancelFired1, isFalse); |
| 125 expect(cancelFired2, isFalse); |
| 126 |
| 127 completer.complete(); |
| 128 await flushMicrotasks(); |
| 129 expect(cancelFired1, isTrue); |
| 130 expect(cancelFired2, isTrue); |
| 131 }); |
| 132 }); |
| 133 |
| 134 group("with a pause callback", () { |
| 135 test("invokes the callback when pause is called", () async { |
| 136 var pauseCount = 0; |
| 137 var controller = new StreamController(); |
| 138 var subscription = controller.stream |
| 139 .transform(subscriptionTransformer( |
| 140 handlePause: expectAsync1((inner) { |
| 141 pauseCount++; |
| 142 inner.pause(); |
| 143 }, count: 3))) |
| 144 .listen(expectAsync1((_) {}, count: 0)); |
| 145 |
| 146 await flushMicrotasks(); |
| 147 expect(pauseCount, equals(0)); |
| 148 |
| 149 subscription.pause(); |
| 150 await flushMicrotasks(); |
| 151 expect(pauseCount, equals(1)); |
| 152 |
| 153 subscription.pause(); |
| 154 await flushMicrotasks(); |
| 155 expect(pauseCount, equals(2)); |
| 156 |
| 157 subscription.resume(); |
| 158 subscription.resume(); |
| 159 await flushMicrotasks(); |
| 160 expect(pauseCount, equals(2)); |
| 161 |
| 162 subscription.pause(); |
| 163 await flushMicrotasks(); |
| 164 expect(pauseCount, equals(3)); |
| 165 }); |
| 166 |
| 167 test("doesn't invoke the callback when the subscription has been canceled", |
| 168 () async { |
| 169 var controller = new StreamController(); |
| 170 var subscription = controller.stream |
| 171 .transform(subscriptionTransformer( |
| 172 handlePause: expectAsync1((_) {}, count: 0))) |
| 173 .listen(expectAsync1((_) {}, count: 0)); |
| 174 |
| 175 subscription.cancel(); |
| 176 subscription.pause(); |
| 177 subscription.pause(); |
| 178 subscription.pause(); |
| 179 }); |
| 180 }); |
| 181 |
| 182 group("with a resume callback", () { |
| 183 test("invokes the callback when resume is called", () async { |
| 184 var resumeCount = 0; |
| 185 var controller = new StreamController(); |
| 186 var subscription = controller.stream |
| 187 .transform(subscriptionTransformer( |
| 188 handleResume: expectAsync1((inner) { |
| 189 resumeCount++; |
| 190 inner.resume(); |
| 191 }, count: 3))) |
| 192 .listen(expectAsync1((_) {}, count: 0)); |
| 193 |
| 194 await flushMicrotasks(); |
| 195 expect(resumeCount, equals(0)); |
| 196 |
| 197 subscription.resume(); |
| 198 await flushMicrotasks(); |
| 199 expect(resumeCount, equals(1)); |
| 200 |
| 201 subscription.pause(); |
| 202 subscription.pause(); |
| 203 await flushMicrotasks(); |
| 204 expect(resumeCount, equals(1)); |
| 205 |
| 206 subscription.resume(); |
| 207 await flushMicrotasks(); |
| 208 expect(resumeCount, equals(2)); |
| 209 |
| 210 subscription.resume(); |
| 211 await flushMicrotasks(); |
| 212 expect(resumeCount, equals(3)); |
| 213 }); |
| 214 |
| 215 test("invokes the callback when a resume future completes", () async { |
| 216 var resumed = false; |
| 217 var controller = new StreamController(); |
| 218 var subscription = controller.stream.transform( |
| 219 subscriptionTransformer(handleResume: expectAsync1((inner) { |
| 220 resumed = true; |
| 221 inner.resume(); |
| 222 }))).listen(expectAsync1((_) {}, count: 0)); |
| 223 |
| 224 var completer = new Completer(); |
| 225 subscription.pause(completer.future); |
| 226 await flushMicrotasks(); |
| 227 expect(resumed, isFalse); |
| 228 |
| 229 completer.complete(); |
| 230 await flushMicrotasks(); |
| 231 expect(resumed, isTrue); |
| 232 }); |
| 233 |
| 234 test("doesn't invoke the callback when the subscription has been canceled", |
| 235 () async { |
| 236 var controller = new StreamController(); |
| 237 var subscription = controller.stream |
| 238 .transform(subscriptionTransformer( |
| 239 handlePause: expectAsync1((_) {}, count: 0))) |
| 240 .listen(expectAsync1((_) {}, count: 0)); |
| 241 |
| 242 subscription.cancel(); |
| 243 subscription.resume(); |
| 244 subscription.resume(); |
| 245 subscription.resume(); |
| 246 }); |
| 247 }); |
| 248 |
| 249 group("when the outer subscription is canceled but the inner is not", () { |
| 250 StreamSubscription subscription; |
| 251 setUp(() { |
| 252 var controller = new StreamController(); |
| 253 subscription = controller.stream |
| 254 .transform(subscriptionTransformer(handleCancel: (_) {})) |
| 255 .listen(expectAsync1((_) {}, count: 0), |
| 256 onError: expectAsync2((_, __) {}, count: 0), |
| 257 onDone: expectAsync0(() {}, count: 0)); |
| 258 subscription.cancel(); |
| 259 controller.add(1); |
| 260 controller.addError("oh no!"); |
| 261 controller.close(); |
| 262 }); |
| 263 |
| 264 test("doesn't call a new onData", () async { |
| 265 subscription.onData(expectAsync1((_) {}, count: 0)); |
| 266 await flushMicrotasks(); |
| 267 }); |
| 268 |
| 269 test("doesn't call a new onError", () async { |
| 270 subscription.onError(expectAsync2((_, __) {}, count: 0)); |
| 271 await flushMicrotasks(); |
| 272 }); |
| 273 |
| 274 test("doesn't call a new onDone", () async { |
| 275 subscription.onDone(expectAsync0(() {}, count: 0)); |
| 276 await flushMicrotasks(); |
| 277 }); |
| 278 |
| 279 test("isPaused returns false", () { |
| 280 expect(subscription.isPaused, isFalse); |
| 281 }); |
| 282 |
| 283 test("asFuture never completes", () async { |
| 284 subscription.asFuture().then(expectAsync1((_) {}, count: 0)); |
| 285 await flushMicrotasks(); |
| 286 }); |
| 287 }); |
| 288 } |
OLD | NEW |