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