OLD | NEW |
(Empty) | |
| 1 // Copyright (c) 2013, 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 import "dart:collection"; |
| 7 import "package:async/result.dart"; |
| 8 import "package:unittest/unittest.dart"; |
| 9 |
| 10 void main() { |
| 11 StackTrace stack; |
| 12 try { throw 0; } catch (e, s) { stack = s; } |
| 13 |
| 14 test("create result value", () { |
| 15 Result<int> result = new Result<int>.value(42); |
| 16 expect(result.isValue, isTrue); |
| 17 expect(result.isError, isFalse); |
| 18 ValueResult value = result.asValue; |
| 19 expect(value.value, equals(42)); |
| 20 }); |
| 21 |
| 22 test("create result value 2", () { |
| 23 Result<int> result = new ValueResult<int>(42); |
| 24 expect(result.isValue, isTrue); |
| 25 expect(result.isError, isFalse); |
| 26 ValueResult<int> value = result.asValue; |
| 27 expect(value.value, equals(42)); |
| 28 }); |
| 29 |
| 30 test("create result error", () { |
| 31 Result<bool> result = new Result<bool>.error("BAD", stack); |
| 32 expect(result.isValue, isFalse); |
| 33 expect(result.isError, isTrue); |
| 34 ErrorResult error = result.asError; |
| 35 expect(error.error, equals("BAD")); |
| 36 expect(error.stackTrace, same(stack)); |
| 37 }); |
| 38 |
| 39 test("create result error 2", () { |
| 40 Result<bool> result = new ErrorResult<bool>("BAD", stack); |
| 41 expect(result.isValue, isFalse); |
| 42 expect(result.isError, isTrue); |
| 43 ErrorResult error = result.asError; |
| 44 expect(error.error, equals("BAD")); |
| 45 expect(error.stackTrace, same(stack)); |
| 46 }); |
| 47 |
| 48 test("create result error no stack", () { |
| 49 Result<bool> result = new Result<bool>.error("BAD"); |
| 50 expect(result.isValue, isFalse); |
| 51 expect(result.isError, isTrue); |
| 52 ErrorResult error = result.asError; |
| 53 expect(error.error, equals("BAD")); |
| 54 expect(error.stackTrace, isNull); |
| 55 }); |
| 56 |
| 57 test("complete with value", () { |
| 58 Result<int> result = new ValueResult<int>(42); |
| 59 Completer c = new Completer<int>(); |
| 60 c.future.then(expectAsync((int v) { expect(v, equals(42)); }), |
| 61 onError: (e, s) { fail("Unexpected error"); }); |
| 62 result.complete(c); |
| 63 }); |
| 64 |
| 65 test("complete with error", () { |
| 66 Result<bool> result = new ErrorResult("BAD", stack); |
| 67 Completer c = new Completer<bool>(); |
| 68 c.future.then((bool v) { Expect.fail("Unexpected value $v"); }, |
| 69 onError: expectAsync((e, s) { |
| 70 expect(e, equals("BAD")); |
| 71 expect(s, same(stack)); |
| 72 })); |
| 73 result.complete(c); |
| 74 }); |
| 75 |
| 76 test("add sink value", () { |
| 77 Result<int> result = new ValueResult<int>(42); |
| 78 EventSink<int> sink = new TestSink( |
| 79 onData: expectAsync((v) { expect(v, equals(42)); }) |
| 80 ); |
| 81 result.addTo(sink); |
| 82 }); |
| 83 |
| 84 test("add sink error", () { |
| 85 Result<bool> result = new ErrorResult("BAD", stack); |
| 86 EventSink<bool> sink = new TestSink( |
| 87 onError: expectAsync((e, s) { |
| 88 expect(e, equals("BAD")); |
| 89 expect(s, same(stack)); |
| 90 }) |
| 91 ); |
| 92 result.addTo(sink); |
| 93 }); |
| 94 |
| 95 test("value as future", () { |
| 96 Result<int> result = new ValueResult<int>(42); |
| 97 result.asFuture.then(expectAsync((int v) { expect(v, equals(42)); }), |
| 98 onError: (e, s) { fail("Unexpected error"); }); |
| 99 }); |
| 100 |
| 101 test("error as future", () { |
| 102 Result<bool> result = new ErrorResult("BAD", stack); |
| 103 result.asFuture.then((bool v) { Expect.fail("Unexpected value $v"); }, |
| 104 onError: expectAsync((e, s) { |
| 105 expect(e, equals("BAD")); |
| 106 expect(s, same(stack)); |
| 107 })); |
| 108 }); |
| 109 |
| 110 test("capture future value", () { |
| 111 Future<int> value = new Future<int>.value(42); |
| 112 Result.capture(value).then(expectAsync((Result result) { |
| 113 expect(result.isValue, isTrue); |
| 114 expect(result.isError, isFalse); |
| 115 ValueResult value = result.asValue; |
| 116 expect(value.value, equals(42)); |
| 117 }), onError: (e, s) { |
| 118 Expect.fail("Unexpected error: $e"); |
| 119 }); |
| 120 }); |
| 121 |
| 122 test("capture future error", () { |
| 123 Future<bool> value = new Future<bool>.error("BAD", stack); |
| 124 Result.capture(value).then(expectAsync((Result result) { |
| 125 expect(result.isValue, isFalse); |
| 126 expect(result.isError, isTrue); |
| 127 ErrorResult error = result.asError; |
| 128 expect(error.error, equals("BAD")); |
| 129 expect(error.stackTrace, same(stack)); |
| 130 }), onError: (e, s) { |
| 131 Expect.fail("Unexpected error: $e"); |
| 132 }); |
| 133 }); |
| 134 |
| 135 test("release future value", () { |
| 136 Future<Result<int>> future = |
| 137 new Future<Result<int>>.value(new Result<int>.value(42)); |
| 138 Result.release(future).then(expectAsync((v) { |
| 139 expect(v, equals(42)); |
| 140 }), onError: (e, s) { |
| 141 Expect.fail("Unexpected error: $e"); |
| 142 }); |
| 143 }); |
| 144 |
| 145 test("release future error", () { |
| 146 // An error in the result is unwrapped and reified by release. |
| 147 Future<Result<bool>> future = |
| 148 new Future<Result<bool>>.value(new Result<bool>.error("BAD", stack)); |
| 149 Result.release(future).then((v) { |
| 150 Expect.fail("Unexpected value: $v"); |
| 151 }, onError: expectAsync((e, s) { |
| 152 expect(e, equals("BAD")); |
| 153 expect(s, same(stack)); |
| 154 })); |
| 155 }); |
| 156 |
| 157 test("release future real error", () { |
| 158 // An error in the error lane is passed through by release. |
| 159 Future<Result<bool>> future = new Future<Result<bool>>.error("BAD", stack); |
| 160 Result.release(future).then((v) { |
| 161 Expect.fail("Unexpected value: $v"); |
| 162 }, onError: expectAsync((e, s) { |
| 163 expect(e, equals("BAD")); |
| 164 expect(s, same(stack)); |
| 165 })); |
| 166 }); |
| 167 |
| 168 test("capture stream", () { |
| 169 StreamController<int> c = new StreamController<int>(); |
| 170 Stream<Result> stream = Result.captureStream(c.stream); |
| 171 var expectedList = new Queue.from([new Result.value(42), |
| 172 new Result.error("BAD", stack), |
| 173 new Result.value(37)]); |
| 174 void listener(Result actual) { |
| 175 expect(expectedList.isEmpty, isFalse); |
| 176 expectResult(actual, expectedList.removeFirst()); |
| 177 } |
| 178 stream.listen(expectAsync(listener, count: 3), |
| 179 onError: (e, s) { fail("Unexpected error: $e"); }, |
| 180 onDone: expectAsync((){}), |
| 181 cancelOnError: true); |
| 182 c.add(42); |
| 183 c.addError("BAD", stack); |
| 184 c.add(37); |
| 185 c.close(); |
| 186 }); |
| 187 |
| 188 test("release stream", () { |
| 189 StreamController<Result<int>> c = new StreamController<Result<int>>(); |
| 190 Stream<int> stream = Result.releaseStream(c.stream); |
| 191 List events = [new Result<int>.value(42), |
| 192 new Result<int>.error("BAD", stack), |
| 193 new Result<int>.value(37)]; |
| 194 // Expect the data events, and an extra error event. |
| 195 var expectedList = new Queue.from(events)..add(new Result.error("BAD2")); |
| 196 void dataListener(int v) { |
| 197 expect(expectedList.isEmpty, isFalse); |
| 198 Result expected = expectedList.removeFirst(); |
| 199 expect(expected.isValue, isTrue); |
| 200 expect(v, equals(expected.asValue.value)); |
| 201 } |
| 202 void errorListener(error, StackTrace stackTrace) { |
| 203 expect(expectedList.isEmpty, isFalse); |
| 204 Result expected = expectedList.removeFirst(); |
| 205 expect(expected.isError, isTrue); |
| 206 expect(error, equals(expected.asError.error)); |
| 207 expect(stackTrace, same(expected.asError.stackTrace)); |
| 208 } |
| 209 stream.listen(expectAsync(dataListener, count: 2), |
| 210 onError: expectAsync(errorListener, count: 2), |
| 211 onDone: expectAsync((){})); |
| 212 for (Result<int> result in events) { |
| 213 c.add(result); // Result value or error in data line. |
| 214 } |
| 215 c.addError("BAD2"); // Error in error line. |
| 216 c.close(); |
| 217 }); |
| 218 |
| 219 test("release stream cancel on error", () { |
| 220 StreamController<Result<int>> c = new StreamController<Result<int>>(); |
| 221 Stream<int> stream = Result.releaseStream(c.stream); |
| 222 stream.listen(expectAsync((v) { expect(v, equals(42)); }), |
| 223 onError: expectAsync((e, s) { |
| 224 expect(e, equals("BAD")); |
| 225 expect(s, same(stack)); |
| 226 }), |
| 227 onDone: () { fail("Unexpected done event"); }, |
| 228 cancelOnError: true); |
| 229 c.add(new Result.value(42)); |
| 230 c.add(new Result.error("BAD", stack)); |
| 231 c.add(new Result.value(37)); |
| 232 c.close(); |
| 233 }); |
| 234 } |
| 235 |
| 236 void expectResult(Result actual, Result expected) { |
| 237 expect(actual.isValue, equals(expected.isValue)); |
| 238 expect(actual.isError, equals(expected.isError)); |
| 239 if (actual.isValue) { |
| 240 expect(actual.asValue.value, equals(expected.asValue.value)); |
| 241 } else { |
| 242 expect(actual.asError.error, equals(expected.asError.error)); |
| 243 expect(actual.asError.stackTrace, same(expected.asError.stackTrace)); |
| 244 } |
| 245 } |
| 246 |
| 247 class TestSink<T> implements EventSink<T> { |
| 248 final Function onData; |
| 249 final Function onError; |
| 250 final Function onDone; |
| 251 |
| 252 TestSink({void this.onData(T data) : _nullData, |
| 253 void this.onError(e, StackTrace s) : _nullError, |
| 254 void this.onDone() : _nullDone }); |
| 255 |
| 256 void add(T value) { onData(value); } |
| 257 void addError(error, [StackTrace stack]) { onError(error, stack); } |
| 258 void close() { onDone(); } |
| 259 |
| 260 static void _nullData(value) { Expect.fail("Unexpected sink add: $value"); } |
| 261 static void _nullError(e, StackTrace s) { |
| 262 Expect.fail("Unexpected sink addError: $e"); |
| 263 } |
| 264 static void _nullDone() { Expect.fail("Unepxected sink close"); } |
| 265 } |
OLD | NEW |