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 filevents. |
| 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 var controller; |
| 14 setUp(() { |
| 15 controller = new StreamController(); |
| 16 }); |
| 17 |
| 18 group("fromStreamTransformer", () { |
| 19 test("transforms data events", () { |
| 20 var transformer = new StreamSinkTransformer.fromStreamTransformer( |
| 21 new StreamTransformer.fromHandlers(handleData: (i, sink) { |
| 22 sink.add(i * 2); |
| 23 })); |
| 24 var sink = transformer.bind(controller.sink); |
| 25 |
| 26 var results = []; |
| 27 controller.stream.listen(results.add, onDone: expectAsync0(() { |
| 28 expect(results, equals([2, 4, 6])); |
| 29 })); |
| 30 |
| 31 sink.add(1); |
| 32 sink.add(2); |
| 33 sink.add(3); |
| 34 sink.close(); |
| 35 }); |
| 36 |
| 37 test("transforms error events", () { |
| 38 var transformer = new StreamSinkTransformer.fromStreamTransformer( |
| 39 new StreamTransformer.fromHandlers( |
| 40 handleError: (i, stackTrace, sink) { |
| 41 sink.addError((i as num) * 2, stackTrace); |
| 42 })); |
| 43 var sink = transformer.bind(controller.sink); |
| 44 |
| 45 var results = []; |
| 46 controller.stream.listen(expectAsync1((_) {}, count: 0), |
| 47 onError: (error, stackTrace) { |
| 48 results.add(error); |
| 49 }, onDone: expectAsync0(() { |
| 50 expect(results, equals([2, 4, 6])); |
| 51 })); |
| 52 |
| 53 sink.addError(1); |
| 54 sink.addError(2); |
| 55 sink.addError(3); |
| 56 sink.close(); |
| 57 }); |
| 58 |
| 59 test("transforms done events", () { |
| 60 var transformer = new StreamSinkTransformer.fromStreamTransformer( |
| 61 new StreamTransformer.fromHandlers(handleDone: (sink) { |
| 62 sink.add(1); |
| 63 sink.close(); |
| 64 })); |
| 65 var sink = transformer.bind(controller.sink); |
| 66 |
| 67 var results = []; |
| 68 controller.stream.listen(results.add, onDone: expectAsync0(() { |
| 69 expect(results, equals([1])); |
| 70 })); |
| 71 |
| 72 sink.close(); |
| 73 }); |
| 74 |
| 75 test("forwards the future from inner.close", () async { |
| 76 var transformer = new StreamSinkTransformer.fromStreamTransformer( |
| 77 new StreamTransformer.fromHandlers()); |
| 78 var innerSink = new CompleterStreamSink(); |
| 79 var sink = transformer.bind(innerSink); |
| 80 |
| 81 // The futures shouldn't complete until the inner sink's close future |
| 82 // completes. |
| 83 var doneResult = new ResultFuture(sink.done); |
| 84 doneResult.catchError((_) {}); |
| 85 var closeResult = new ResultFuture(sink.close()); |
| 86 closeResult.catchError((_) {}); |
| 87 await flushMicrotasks(); |
| 88 expect(doneResult.isComplete, isFalse); |
| 89 expect(closeResult.isComplete, isFalse); |
| 90 |
| 91 // Once the inner sink is completed, the futures should fire. |
| 92 innerSink.completer.complete(); |
| 93 await flushMicrotasks(); |
| 94 expect(doneResult.isComplete, isTrue); |
| 95 expect(closeResult.isComplete, isTrue); |
| 96 }); |
| 97 |
| 98 test("doesn't top-level the future from inner.close", () async { |
| 99 var transformer = new StreamSinkTransformer.fromStreamTransformer( |
| 100 new StreamTransformer.fromHandlers(handleData: (_, sink) { |
| 101 sink.close(); |
| 102 })); |
| 103 var innerSink = new CompleterStreamSink(); |
| 104 var sink = transformer.bind(innerSink); |
| 105 |
| 106 // This will close the inner sink, but it shouldn't top-level the error. |
| 107 sink.add(1); |
| 108 innerSink.completer.completeError("oh no"); |
| 109 await flushMicrotasks(); |
| 110 |
| 111 // The error should be piped through done and close even if they're called |
| 112 // after the underlying sink is closed. |
| 113 expect(sink.done, throwsA("oh no")); |
| 114 expect(sink.close(), throwsA("oh no")); |
| 115 }); |
| 116 }); |
| 117 |
| 118 group("fromHandlers", () { |
| 119 test("transforms data events", () { |
| 120 var transformer = |
| 121 new StreamSinkTransformer.fromHandlers(handleData: (i, sink) { |
| 122 sink.add(i * 2); |
| 123 }); |
| 124 var sink = transformer.bind(controller.sink); |
| 125 |
| 126 var results = []; |
| 127 controller.stream.listen(results.add, onDone: expectAsync0(() { |
| 128 expect(results, equals([2, 4, 6])); |
| 129 })); |
| 130 |
| 131 sink.add(1); |
| 132 sink.add(2); |
| 133 sink.add(3); |
| 134 sink.close(); |
| 135 }); |
| 136 |
| 137 test("transforms error events", () { |
| 138 var transformer = new StreamSinkTransformer.fromHandlers( |
| 139 handleError: (i, stackTrace, sink) { |
| 140 sink.addError((i as num) * 2, stackTrace); |
| 141 }); |
| 142 var sink = transformer.bind(controller.sink); |
| 143 |
| 144 var results = []; |
| 145 controller.stream.listen(expectAsync1((_) {}, count: 0), |
| 146 onError: (error, stackTrace) { |
| 147 results.add(error); |
| 148 }, onDone: expectAsync0(() { |
| 149 expect(results, equals([2, 4, 6])); |
| 150 })); |
| 151 |
| 152 sink.addError(1); |
| 153 sink.addError(2); |
| 154 sink.addError(3); |
| 155 sink.close(); |
| 156 }); |
| 157 |
| 158 test("transforms done events", () { |
| 159 var transformer = |
| 160 new StreamSinkTransformer.fromHandlers(handleDone: (sink) { |
| 161 sink.add(1); |
| 162 sink.close(); |
| 163 }); |
| 164 var sink = transformer.bind(controller.sink); |
| 165 |
| 166 var results = []; |
| 167 controller.stream.listen(results.add, onDone: expectAsync0(() { |
| 168 expect(results, equals([1])); |
| 169 })); |
| 170 |
| 171 sink.close(); |
| 172 }); |
| 173 |
| 174 test("forwards the future from inner.close", () async { |
| 175 var transformer = new StreamSinkTransformer.fromHandlers(); |
| 176 var innerSink = new CompleterStreamSink(); |
| 177 var sink = transformer.bind(innerSink); |
| 178 |
| 179 // The futures shouldn't complete until the inner sink's close future |
| 180 // completes. |
| 181 var doneResult = new ResultFuture(sink.done); |
| 182 doneResult.catchError((_) {}); |
| 183 var closeResult = new ResultFuture(sink.close()); |
| 184 closeResult.catchError((_) {}); |
| 185 await flushMicrotasks(); |
| 186 expect(doneResult.isComplete, isFalse); |
| 187 expect(closeResult.isComplete, isFalse); |
| 188 |
| 189 // Once the inner sink is completed, the futures should fire. |
| 190 innerSink.completer.complete(); |
| 191 await flushMicrotasks(); |
| 192 expect(doneResult.isComplete, isTrue); |
| 193 expect(closeResult.isComplete, isTrue); |
| 194 }); |
| 195 |
| 196 test("doesn't top-level the future from inner.close", () async { |
| 197 var transformer = |
| 198 new StreamSinkTransformer.fromHandlers(handleData: (_, sink) { |
| 199 sink.close(); |
| 200 }); |
| 201 var innerSink = new CompleterStreamSink(); |
| 202 var sink = transformer.bind(innerSink); |
| 203 |
| 204 // This will close the inner sink, but it shouldn't top-level the error. |
| 205 sink.add(1); |
| 206 innerSink.completer.completeError("oh no"); |
| 207 await flushMicrotasks(); |
| 208 |
| 209 // The error should be piped through done and close even if they're called |
| 210 // after the underlying sink is closed. |
| 211 expect(sink.done, throwsA("oh no")); |
| 212 expect(sink.close(), throwsA("oh no")); |
| 213 }); |
| 214 }); |
| 215 } |
OLD | NEW |