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 | |
8 import "package:async/async.dart"; | |
9 import "package:stack_trace/stack_trace.dart"; | |
10 import "package:test/test.dart"; | |
11 | |
12 void main() { | |
13 var stack = new Trace.current(); | |
14 | |
15 test("create result value", () { | |
16 Result<int> result = new Result<int>.value(42); | |
17 expect(result.isValue, isTrue); | |
18 expect(result.isError, isFalse); | |
19 ValueResult value = result.asValue; | |
20 expect(value.value, equals(42)); | |
21 }); | |
22 | |
23 test("create result value 2", () { | |
24 Result<int> result = new ValueResult<int>(42); | |
25 expect(result.isValue, isTrue); | |
26 expect(result.isError, isFalse); | |
27 ValueResult<int> value = result.asValue; | |
28 expect(value.value, equals(42)); | |
29 }); | |
30 | |
31 test("create result error", () { | |
32 Result<bool> result = new Result<bool>.error("BAD", stack); | |
33 expect(result.isValue, isFalse); | |
34 expect(result.isError, isTrue); | |
35 ErrorResult error = result.asError; | |
36 expect(error.error, equals("BAD")); | |
37 expect(error.stackTrace, same(stack)); | |
38 }); | |
39 | |
40 test("create result error 2", () { | |
41 Result<bool> result = new ErrorResult("BAD", stack); | |
42 expect(result.isValue, isFalse); | |
43 expect(result.isError, isTrue); | |
44 ErrorResult error = result.asError; | |
45 expect(error.error, equals("BAD")); | |
46 expect(error.stackTrace, same(stack)); | |
47 }); | |
48 | |
49 test("create result error no stack", () { | |
50 Result<bool> result = new Result<bool>.error("BAD"); | |
51 expect(result.isValue, isFalse); | |
52 expect(result.isError, isTrue); | |
53 ErrorResult error = result.asError; | |
54 expect(error.error, equals("BAD")); | |
55 expect(error.stackTrace, isNull); | |
56 }); | |
57 | |
58 test("complete with value", () { | |
59 Result<int> result = new ValueResult<int>(42); | |
60 var c = new Completer<int>(); | |
61 c.future.then(expectAsync1((int v) { | |
62 expect(v, equals(42)); | |
63 }), onError: (e, s) { | |
64 fail("Unexpected error"); | |
65 }); | |
66 result.complete(c); | |
67 }); | |
68 | |
69 test("complete with error", () { | |
70 Result<bool> result = new ErrorResult("BAD", stack); | |
71 var c = new Completer<bool>(); | |
72 c.future.then((bool v) { | |
73 fail("Unexpected value $v"); | |
74 }, onError: expectAsync2((e, s) { | |
75 expect(e, equals("BAD")); | |
76 expect(s, same(stack)); | |
77 })); | |
78 result.complete(c); | |
79 }); | |
80 | |
81 test("add sink value", () { | |
82 var result = new ValueResult<int>(42); | |
83 EventSink<int> sink = new TestSink(onData: expectAsync1((v) { | |
84 expect(v, equals(42)); | |
85 })); | |
86 result.addTo(sink); | |
87 }); | |
88 | |
89 test("add sink error", () { | |
90 Result<bool> result = new ErrorResult("BAD", stack); | |
91 EventSink<bool> sink = new TestSink(onError: expectAsync2((e, s) { | |
92 expect(e, equals("BAD")); | |
93 expect(s, same(stack)); | |
94 })); | |
95 result.addTo(sink); | |
96 }); | |
97 | |
98 test("value as future", () { | |
99 Result<int> result = new ValueResult<int>(42); | |
100 result.asFuture.then(expectAsync1((int v) { | |
101 expect(v, equals(42)); | |
102 }), onError: (e, s) { | |
103 fail("Unexpected error"); | |
104 }); | |
105 }); | |
106 | |
107 test("error as future", () { | |
108 Result<bool> result = new ErrorResult("BAD", stack); | |
109 result.asFuture.then((bool v) { | |
110 fail("Unexpected value $v"); | |
111 }, onError: expectAsync2((e, s) { | |
112 expect(e, equals("BAD")); | |
113 expect(s, same(stack)); | |
114 })); | |
115 }); | |
116 | |
117 test("capture future value", () { | |
118 Future<int> value = new Future<int>.value(42); | |
119 Result.capture(value).then(expectAsync1((Result result) { | |
120 expect(result.isValue, isTrue); | |
121 expect(result.isError, isFalse); | |
122 ValueResult value = result.asValue; | |
123 expect(value.value, equals(42)); | |
124 }), onError: (e, s) { | |
125 fail("Unexpected error: $e"); | |
126 }); | |
127 }); | |
128 | |
129 test("capture future error", () { | |
130 Future<bool> value = new Future<bool>.error("BAD", stack); | |
131 Result.capture(value).then(expectAsync1((Result result) { | |
132 expect(result.isValue, isFalse); | |
133 expect(result.isError, isTrue); | |
134 ErrorResult error = result.asError; | |
135 expect(error.error, equals("BAD")); | |
136 expect(error.stackTrace, same(stack)); | |
137 }), onError: (e, s) { | |
138 fail("Unexpected error: $e"); | |
139 }); | |
140 }); | |
141 | |
142 test("release future value", () { | |
143 Future<Result<int>> future = | |
144 new Future<Result<int>>.value(new Result<int>.value(42)); | |
145 Result.release(future).then(expectAsync1((v) { | |
146 expect(v, equals(42)); | |
147 }), onError: (e, s) { | |
148 fail("Unexpected error: $e"); | |
149 }); | |
150 }); | |
151 | |
152 test("release future error", () { | |
153 // An error in the result is unwrapped and reified by release. | |
154 Future<Result<bool>> future = | |
155 new Future<Result<bool>>.value(new Result<bool>.error("BAD", stack)); | |
156 Result.release(future).then((v) { | |
157 fail("Unexpected value: $v"); | |
158 }, onError: expectAsync2((e, s) { | |
159 expect(e, equals("BAD")); | |
160 expect(s, same(stack)); | |
161 })); | |
162 }); | |
163 | |
164 test("release future real error", () { | |
165 // An error in the error lane is passed through by release. | |
166 Future<Result<bool>> future = new Future<Result<bool>>.error("BAD", stack); | |
167 Result.release(future).then((v) { | |
168 fail("Unexpected value: $v"); | |
169 }, onError: expectAsync2((e, s) { | |
170 expect(e, equals("BAD")); | |
171 expect(s, same(stack)); | |
172 })); | |
173 }); | |
174 | |
175 test("capture stream", () { | |
176 StreamController<int> c = new StreamController<int>(); | |
177 Stream<Result> stream = Result.captureStream(c.stream); | |
178 var expectedList = new Queue.from([ | |
179 new Result.value(42), | |
180 new Result.error("BAD", stack), | |
181 new Result.value(37) | |
182 ]); | |
183 void listener(Result actual) { | |
184 expect(expectedList.isEmpty, isFalse); | |
185 expectResult(actual, expectedList.removeFirst()); | |
186 } | |
187 | |
188 stream.listen(expectAsync1(listener, count: 3), onError: (e, s) { | |
189 fail("Unexpected error: $e"); | |
190 }, onDone: expectAsync0(() {}), cancelOnError: true); | |
191 c.add(42); | |
192 c.addError("BAD", stack); | |
193 c.add(37); | |
194 c.close(); | |
195 }); | |
196 | |
197 test("release stream", () { | |
198 StreamController<Result<int>> c = new StreamController<Result<int>>(); | |
199 Stream<int> stream = Result.releaseStream(c.stream); | |
200 var events = [ | |
201 new Result<int>.value(42), | |
202 new Result<int>.error("BAD", stack), | |
203 new Result<int>.value(37) | |
204 ]; | |
205 // Expect the data events, and an extra error event. | |
206 var expectedList = new Queue.from(events) | |
207 ..add(new Result.error("BAD2", stack)); | |
208 | |
209 void dataListener(int v) { | |
210 expect(expectedList.isEmpty, isFalse); | |
211 Result expected = expectedList.removeFirst(); | |
212 expect(expected.isValue, isTrue); | |
213 expect(v, equals(expected.asValue.value)); | |
214 } | |
215 | |
216 void errorListener(error, StackTrace stackTrace) { | |
217 expect(expectedList.isEmpty, isFalse); | |
218 Result expected = expectedList.removeFirst(); | |
219 expect(expected.isError, isTrue); | |
220 expect(error, equals(expected.asError.error)); | |
221 expect(stackTrace, same(expected.asError.stackTrace)); | |
222 } | |
223 | |
224 stream.listen(expectAsync1(dataListener, count: 2), | |
225 onError: expectAsync2(errorListener, count: 2), | |
226 onDone: expectAsync0(() {})); | |
227 for (Result<int> result in events) { | |
228 c.add(result); // Result value or error in data line. | |
229 } | |
230 c.addError("BAD2", stack); // Error in error line. | |
231 c.close(); | |
232 }); | |
233 | |
234 test("release stream cancel on error", () { | |
235 StreamController<Result<int>> c = new StreamController<Result<int>>(); | |
236 Stream<int> stream = Result.releaseStream(c.stream); | |
237 stream.listen(expectAsync1((v) { | |
238 expect(v, equals(42)); | |
239 }), onError: expectAsync2((e, s) { | |
240 expect(e, equals("BAD")); | |
241 expect(s, same(stack)); | |
242 }), onDone: () { | |
243 fail("Unexpected done event"); | |
244 }, cancelOnError: true); | |
245 c.add(new Result.value(42)); | |
246 c.add(new Result.error("BAD", stack)); | |
247 c.add(new Result.value(37)); | |
248 c.close(); | |
249 }); | |
250 | |
251 test("flatten error 1", () { | |
252 Result<int> error = new Result<int>.error("BAD", stack); | |
253 Result<int> flattened = | |
254 Result.flatten(new Result<Result<int>>.error("BAD", stack)); | |
255 expectResult(flattened, error); | |
256 }); | |
257 | |
258 test("flatten error 2", () { | |
259 Result<int> error = new Result<int>.error("BAD", stack); | |
260 Result<Result<int>> result = new Result<Result<int>>.value(error); | |
261 Result<int> flattened = Result.flatten(result); | |
262 expectResult(flattened, error); | |
263 }); | |
264 | |
265 test("flatten value", () { | |
266 Result<Result<int>> result = | |
267 new Result<Result<int>>.value(new Result<int>.value(42)); | |
268 expectResult(Result.flatten(result), new Result<int>.value(42)); | |
269 }); | |
270 | |
271 test("handle unary", () { | |
272 ErrorResult result = new Result.error("error", stack); | |
273 bool called = false; | |
274 result.handle((error) { | |
275 called = true; | |
276 expect(error, "error"); | |
277 }); | |
278 expect(called, isTrue); | |
279 }); | |
280 | |
281 test("handle binary", () { | |
282 ErrorResult result = new Result.error("error", stack); | |
283 bool called = false; | |
284 result.handle((error, stackTrace) { | |
285 called = true; | |
286 expect(error, "error"); | |
287 expect(stackTrace, same(stack)); | |
288 }); | |
289 expect(called, isTrue); | |
290 }); | |
291 | |
292 test("handle unary and binary", () { | |
293 ErrorResult result = new Result.error("error", stack); | |
294 bool called = false; | |
295 result.handle((error, [stackTrace]) { | |
296 called = true; | |
297 expect(error, "error"); | |
298 expect(stackTrace, same(stack)); | |
299 }); | |
300 expect(called, isTrue); | |
301 }); | |
302 | |
303 test("handle neither unary nor binary", () { | |
304 ErrorResult result = new Result.error("error", stack); | |
305 expect(() => result.handle(() => fail("unreachable")), throws); | |
306 expect(() => result.handle((a, b, c) => fail("unreachable")), throws); | |
307 expect(() => result.handle((a, b, {c}) => fail("unreachable")), throws); | |
308 expect(() => result.handle((a, {b}) => fail("unreachable")), throws); | |
309 expect(() => result.handle(({a, b}) => fail("unreachable")), throws); | |
310 expect(() => result.handle(({a}) => fail("unreachable")), throws); | |
311 }); | |
312 } | |
313 | |
314 void expectResult(Result actual, Result expected) { | |
315 expect(actual.isValue, equals(expected.isValue)); | |
316 expect(actual.isError, equals(expected.isError)); | |
317 if (actual.isValue) { | |
318 expect(actual.asValue.value, equals(expected.asValue.value)); | |
319 } else { | |
320 expect(actual.asError.error, equals(expected.asError.error)); | |
321 expect(actual.asError.stackTrace, same(expected.asError.stackTrace)); | |
322 } | |
323 } | |
324 | |
325 class TestSink<T> implements EventSink<T> { | |
326 final Function onData; | |
327 final Function onError; | |
328 final Function onDone; | |
329 | |
330 TestSink( | |
331 {void this.onData(T data): _nullData, | |
332 void this.onError(e, StackTrace s): _nullError, | |
333 void this.onDone(): _nullDone}); | |
334 | |
335 void add(T value) { | |
336 onData(value); | |
337 } | |
338 | |
339 void addError(error, [StackTrace stack]) { | |
340 onError(error, stack); | |
341 } | |
342 | |
343 void close() { | |
344 onDone(); | |
345 } | |
346 | |
347 static void _nullData(value) { | |
348 fail("Unexpected sink add: $value"); | |
349 } | |
350 | |
351 static void _nullError(e, StackTrace s) { | |
352 fail("Unexpected sink addError: $e"); | |
353 } | |
354 | |
355 static void _nullDone() { | |
356 fail("Unepxected sink close"); | |
357 } | |
358 } | |
OLD | NEW |