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 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 test("runs once after all tests", () { |
| 14 return expectTestsPass(() { |
| 15 var test1Run = false; |
| 16 var test2Run = false; |
| 17 var tearDownAllRun = false; |
| 18 tearDownAll(() { |
| 19 expect(test1Run, isTrue); |
| 20 expect(test2Run, isTrue); |
| 21 expect(tearDownAllRun, isFalse); |
| 22 tearDownAllRun = true; |
| 23 }); |
| 24 |
| 25 test("test 1", () { |
| 26 expect(tearDownAllRun, isFalse); |
| 27 test1Run = true; |
| 28 }); |
| 29 |
| 30 test("test 2", () { |
| 31 expect(tearDownAllRun, isFalse); |
| 32 test2Run = true; |
| 33 }); |
| 34 }); |
| 35 }); |
| 36 |
| 37 test("runs once per group, inside-out", () { |
| 38 return expectTestsPass(() { |
| 39 var tearDownAll1Run = false; |
| 40 var tearDownAll2Run = false; |
| 41 var tearDownAll3Run = false; |
| 42 var testRun = false; |
| 43 tearDownAll(() { |
| 44 expect(tearDownAll1Run, isFalse); |
| 45 expect(tearDownAll2Run, isTrue); |
| 46 expect(tearDownAll3Run, isTrue); |
| 47 expect(testRun, isTrue); |
| 48 tearDownAll1Run = true; |
| 49 }); |
| 50 |
| 51 group("mid", () { |
| 52 tearDownAll(() { |
| 53 expect(tearDownAll1Run, isFalse); |
| 54 expect(tearDownAll2Run, isFalse); |
| 55 expect(tearDownAll3Run, isTrue); |
| 56 expect(testRun, isTrue); |
| 57 tearDownAll2Run = true; |
| 58 }); |
| 59 |
| 60 group("inner", () { |
| 61 tearDownAll(() { |
| 62 expect(tearDownAll1Run, isFalse); |
| 63 expect(tearDownAll2Run, isFalse); |
| 64 expect(tearDownAll3Run, isFalse); |
| 65 expect(testRun, isTrue); |
| 66 tearDownAll3Run = true; |
| 67 }); |
| 68 |
| 69 test("test", () { |
| 70 expect(tearDownAll1Run, isFalse); |
| 71 expect(tearDownAll2Run, isFalse); |
| 72 expect(tearDownAll3Run, isFalse); |
| 73 testRun = true; |
| 74 }); |
| 75 }); |
| 76 }); |
| 77 }); |
| 78 }); |
| 79 |
| 80 test("runs after tearDowns", () { |
| 81 return expectTestsPass(() { |
| 82 var tearDown1Run = false; |
| 83 var tearDown2Run = false; |
| 84 var tearDownAllRun = false; |
| 85 tearDown(() { |
| 86 expect(tearDownAllRun, isFalse); |
| 87 tearDown1Run = true; |
| 88 }); |
| 89 |
| 90 tearDownAll(() { |
| 91 expect(tearDown1Run, isTrue); |
| 92 expect(tearDown2Run, isTrue); |
| 93 expect(tearDownAllRun, isFalse); |
| 94 tearDownAllRun = true; |
| 95 }); |
| 96 |
| 97 tearDown(() { |
| 98 expect(tearDownAllRun, isFalse); |
| 99 tearDown2Run = true; |
| 100 }); |
| 101 |
| 102 test("test", () { |
| 103 expect(tearDownAllRun, isFalse); |
| 104 }); |
| 105 }); |
| 106 }); |
| 107 |
| 108 test("multiples run in reverse order", () { |
| 109 return expectTestsPass(() { |
| 110 var tearDownAll1Run = false; |
| 111 var tearDownAll2Run = false; |
| 112 var tearDownAll3Run = false; |
| 113 tearDownAll(() { |
| 114 expect(tearDownAll1Run, isFalse); |
| 115 expect(tearDownAll2Run, isTrue); |
| 116 expect(tearDownAll3Run, isTrue); |
| 117 tearDownAll1Run = true; |
| 118 }); |
| 119 |
| 120 tearDownAll(() { |
| 121 expect(tearDownAll1Run, isFalse); |
| 122 expect(tearDownAll2Run, isFalse); |
| 123 expect(tearDownAll3Run, isTrue); |
| 124 tearDownAll2Run = true; |
| 125 }); |
| 126 |
| 127 tearDownAll(() { |
| 128 expect(tearDownAll1Run, isFalse); |
| 129 expect(tearDownAll2Run, isFalse); |
| 130 expect(tearDownAll3Run, isFalse); |
| 131 tearDownAll3Run = true; |
| 132 }); |
| 133 |
| 134 test("test", () { |
| 135 expect(tearDownAll1Run, isFalse); |
| 136 expect(tearDownAll2Run, isFalse); |
| 137 expect(tearDownAll3Run, isFalse); |
| 138 }); |
| 139 }); |
| 140 }); |
| 141 |
| 142 group("asynchronously", () { |
| 143 test("blocks additional tearDownAlls on in-band async", () { |
| 144 return expectTestsPass(() { |
| 145 var tearDownAll1Run = false; |
| 146 var tearDownAll2Run = false; |
| 147 var tearDownAll3Run = false; |
| 148 tearDownAll(() async { |
| 149 expect(tearDownAll1Run, isFalse); |
| 150 expect(tearDownAll2Run, isTrue); |
| 151 expect(tearDownAll3Run, isTrue); |
| 152 await pumpEventQueue(); |
| 153 tearDownAll1Run = true; |
| 154 }); |
| 155 |
| 156 tearDownAll(() async { |
| 157 expect(tearDownAll1Run, isFalse); |
| 158 expect(tearDownAll2Run, isFalse); |
| 159 expect(tearDownAll3Run, isTrue); |
| 160 await pumpEventQueue(); |
| 161 tearDownAll2Run = true; |
| 162 }); |
| 163 |
| 164 tearDownAll(() async { |
| 165 expect(tearDownAll1Run, isFalse); |
| 166 expect(tearDownAll2Run, isFalse); |
| 167 expect(tearDownAll3Run, isFalse); |
| 168 await pumpEventQueue(); |
| 169 tearDownAll3Run = true; |
| 170 }); |
| 171 |
| 172 test("test", () { |
| 173 expect(tearDownAll1Run, isFalse); |
| 174 expect(tearDownAll2Run, isFalse); |
| 175 expect(tearDownAll3Run, isFalse); |
| 176 }); |
| 177 }); |
| 178 }); |
| 179 |
| 180 test("doesn't block additional tearDownAlls on out-of-band async", () { |
| 181 return expectTestsPass(() { |
| 182 var tearDownAll1Run = false; |
| 183 var tearDownAll2Run = false; |
| 184 var tearDownAll3Run = false; |
| 185 tearDownAll(() { |
| 186 expect(tearDownAll1Run, isFalse); |
| 187 expect(tearDownAll2Run, isFalse); |
| 188 expect(tearDownAll3Run, isFalse); |
| 189 |
| 190 expect(new Future(() { |
| 191 tearDownAll1Run = true; |
| 192 }), completes); |
| 193 }); |
| 194 |
| 195 tearDownAll(() { |
| 196 expect(tearDownAll1Run, isFalse); |
| 197 expect(tearDownAll2Run, isFalse); |
| 198 expect(tearDownAll3Run, isFalse); |
| 199 |
| 200 expect(new Future(() { |
| 201 tearDownAll2Run = true; |
| 202 }), completes); |
| 203 }); |
| 204 |
| 205 tearDownAll(() { |
| 206 expect(tearDownAll1Run, isFalse); |
| 207 expect(tearDownAll2Run, isFalse); |
| 208 expect(tearDownAll3Run, isFalse); |
| 209 |
| 210 expect(new Future(() { |
| 211 tearDownAll3Run = true; |
| 212 }), completes); |
| 213 }); |
| 214 |
| 215 test("test", () { |
| 216 expect(tearDownAll1Run, isFalse); |
| 217 expect(tearDownAll2Run, isFalse); |
| 218 expect(tearDownAll3Run, isFalse); |
| 219 }); |
| 220 }); |
| 221 }); |
| 222 |
| 223 test("blocks further tests on in-band async", () { |
| 224 return expectTestsPass(() { |
| 225 var tearDownAllRun = false; |
| 226 group("group", () { |
| 227 tearDownAll(() async { |
| 228 expect(tearDownAllRun, isFalse); |
| 229 await pumpEventQueue(); |
| 230 tearDownAllRun = true; |
| 231 }); |
| 232 |
| 233 test("test", () {}); |
| 234 }); |
| 235 |
| 236 test("after", () { |
| 237 expect(tearDownAllRun, isTrue); |
| 238 }); |
| 239 }); |
| 240 }); |
| 241 |
| 242 test("blocks further tests on out-of-band async", () { |
| 243 return expectTestsPass(() { |
| 244 var tearDownAllRun = false; |
| 245 group("group", () { |
| 246 tearDownAll(() async { |
| 247 expect(tearDownAllRun, isFalse); |
| 248 expect(pumpEventQueue().then((_) { |
| 249 tearDownAllRun = true; |
| 250 }), completes); |
| 251 }); |
| 252 |
| 253 test("test", () {}); |
| 254 }); |
| 255 |
| 256 test("after", () { |
| 257 expect(tearDownAllRun, isTrue); |
| 258 }); |
| 259 }); |
| 260 }); |
| 261 }); |
| 262 |
| 263 test("isn't run for a skipped group", () async { |
| 264 // Declare this in the outer test so if it runs, the outer test will fail. |
| 265 var shouldNotRun = expectAsync(() {}, count: 0); |
| 266 |
| 267 var engine = declareEngine(() { |
| 268 group("skipped", () { |
| 269 tearDownAll(shouldNotRun); |
| 270 |
| 271 test("test", () {}); |
| 272 }, skip: true); |
| 273 }); |
| 274 |
| 275 await engine.run(); |
| 276 expect(engine.liveTests, hasLength(1)); |
| 277 expect(engine.skipped, hasLength(1)); |
| 278 expect(engine.liveTests, equals(engine.skipped)); |
| 279 }); |
| 280 |
| 281 test("is emitted through Engine.onTestStarted", () async { |
| 282 var engine = declareEngine(() { |
| 283 tearDownAll(() {}); |
| 284 |
| 285 test("test", () {}); |
| 286 }); |
| 287 |
| 288 var queue = new StreamQueue(engine.onTestStarted); |
| 289 var liveTestFuture = queue.next; |
| 290 var tearDownAllFuture = queue.next; |
| 291 |
| 292 await engine.run(); |
| 293 |
| 294 var tearDownAllLiveTest = await tearDownAllFuture; |
| 295 expect(tearDownAllLiveTest.test.name, equals("(tearDownAll)")); |
| 296 expectTestPassed(tearDownAllLiveTest); |
| 297 |
| 298 // The fake test for tearDownAll should be removed from the engine's live |
| 299 // test list so that reporters don't display it as a passed test. |
| 300 expect(engine.liveTests, isNot(contains(tearDownAllLiveTest))); |
| 301 expect(engine.passed, isNot(contains(tearDownAllLiveTest))); |
| 302 expect(engine.failed, isNot(contains(tearDownAllLiveTest))); |
| 303 expect(engine.skipped, isNot(contains(tearDownAllLiveTest))); |
| 304 expect(engine.active, isNot(contains(tearDownAllLiveTest))); |
| 305 |
| 306 var liveTest = await liveTestFuture; |
| 307 expectTestPassed(await liveTestFuture); |
| 308 expect(engine.liveTests, contains(liveTest)); |
| 309 expect(engine.passed, contains(liveTest)); |
| 310 }); |
| 311 |
| 312 group("with an error", () { |
| 313 test("reports the error and remains in Engine.liveTests", () async { |
| 314 var engine = declareEngine(() { |
| 315 tearDownAll(() => throw new TestFailure("fail")); |
| 316 |
| 317 test("test", () {}); |
| 318 }); |
| 319 |
| 320 var queue = new StreamQueue(engine.onTestStarted); |
| 321 expect(queue.next, completes); |
| 322 var tearDownAllFuture = queue.next; |
| 323 |
| 324 expect(await engine.run(), isFalse); |
| 325 |
| 326 var tearDownAllLiveTest = await tearDownAllFuture; |
| 327 expect(tearDownAllLiveTest.test.name, equals("(tearDownAll)")); |
| 328 expectTestFailed(tearDownAllLiveTest, "fail"); |
| 329 |
| 330 // The fake test for tearDownAll should be removed from the engine's live |
| 331 // test list so that reporters don't display it as a passed test. |
| 332 expect(engine.liveTests, contains(tearDownAllLiveTest)); |
| 333 expect(engine.failed, contains(tearDownAllLiveTest)); |
| 334 expect(engine.passed, isNot(contains(tearDownAllLiveTest))); |
| 335 expect(engine.skipped, isNot(contains(tearDownAllLiveTest))); |
| 336 expect(engine.active, isNot(contains(tearDownAllLiveTest))); |
| 337 }); |
| 338 |
| 339 test("runs further tearDownAlls", () async { |
| 340 // Declare this in the outer test so if it doesn't runs, the outer test |
| 341 // will fail. |
| 342 var shouldRun = expectAsync(() {}); |
| 343 |
| 344 var engine = declareEngine(() { |
| 345 tearDownAll(() => throw "error"); |
| 346 tearDownAll(shouldRun); |
| 347 |
| 348 test("test", () {}); |
| 349 }); |
| 350 |
| 351 expect(await engine.run(), isFalse); |
| 352 }); |
| 353 |
| 354 test("runs outer tearDownAlls", () async { |
| 355 // Declare this in the outer test so if it doesn't runs, the outer test |
| 356 // will fail. |
| 357 var shouldRun = expectAsync(() {}); |
| 358 |
| 359 var engine = declareEngine(() { |
| 360 tearDownAll(shouldRun); |
| 361 |
| 362 group("group", () { |
| 363 tearDownAll(() => throw "error"); |
| 364 |
| 365 test("test", () {}); |
| 366 }); |
| 367 }); |
| 368 |
| 369 expect(await engine.run(), isFalse); |
| 370 }); |
| 371 }); |
| 372 } |
OLD | NEW |