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