Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(79)

Issues Search
    My Issues | Starred     Open | Closed | All

Side by Side Diff: test/declarer_test.dart

Issue 979523002: Move more files around. (Closed) Base URL: git@github.com:dart-lang/unittest@master
Patch Set: Created 5 years, 9 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « test/compact_reporter_test.dart ('k') | test/engine_test.dart » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
(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:unittest/src/backend/declarer.dart';
8 import 'package:unittest/src/backend/suite.dart';
9 import 'package:unittest/unittest.dart';
10
11 Declarer _declarer;
12 Suite _suite;
13
14 void main() {
15 setUp(() {
16 _declarer = new Declarer();
17 _suite = new Suite("suite", []);
18 });
19
20 group(".test()", () {
21 test("declares a test with a description and body", () {
22 var bodyRun = false;
23 _declarer.test("description", () {
24 bodyRun = true;
25 });
26
27 expect(_declarer.tests, hasLength(1));
28 expect(_declarer.tests.single.name, equals("description"));
29
30 return _runTest(0).then(expectAsync((_) {
31 expect(bodyRun, isTrue);
32 }, max: 1));
33 });
34
35 test("declares multiple tests", () {
36 _declarer.test("description 1", () {});
37 _declarer.test("description 2", () {});
38 _declarer.test("description 3", () {});
39
40 expect(_declarer.tests, hasLength(3));
41 expect(_declarer.tests[0].name, equals("description 1"));
42 expect(_declarer.tests[1].name, equals("description 2"));
43 expect(_declarer.tests[2].name, equals("description 3"));
44 });
45 });
46
47 group(".setUp()", () {
48 test("is run before all tests", () {
49 var setUpRun = false;
50 _declarer.setUp(() => setUpRun = true);
51
52 _declarer.test("description 1", expectAsync(() {
53 expect(setUpRun, isTrue);
54 setUpRun = false;
55 }, max: 1));
56
57 _declarer.test("description 2", expectAsync(() {
58 expect(setUpRun, isTrue);
59 setUpRun = false;
60 }, max: 1));
61
62 return _runTest(0).then((_) => _runTest(1));
63 });
64
65 test("can return a Future", () {
66 var setUpRun = false;
67 _declarer.setUp(() {
68 return new Future(() => setUpRun = true);
69 });
70
71 _declarer.test("description", expectAsync(() {
72 expect(setUpRun, isTrue);
73 }, max: 1));
74
75 return _runTest(0);
76 });
77
78 test("can't be called multiple times", () {
79 _declarer.setUp(() {});
80 expect(() => _declarer.setUp(() {}), throwsStateError);
81 });
82 });
83
84 group(".tearDown()", () {
85 test("is run after all tests", () {
86 var tearDownRun;
87 _declarer.setUp(() => tearDownRun = false);
88 _declarer.tearDown(() => tearDownRun = true);
89
90 _declarer.test("description 1", expectAsync(() {
91 expect(tearDownRun, isFalse);
92 }, max: 1));
93
94 _declarer.test("description 2", expectAsync(() {
95 expect(tearDownRun, isFalse);
96 }, max: 1));
97
98 return _runTest(0).then((_) {
99 expect(tearDownRun, isTrue);
100 return _runTest(1);
101 }).then((_) => expect(tearDownRun, isTrue));
102 });
103
104 test("can return a Future", () {
105 var tearDownRun = false;
106 _declarer.tearDown(() {
107 return new Future(() => tearDownRun = true);
108 });
109
110 _declarer.test("description", expectAsync(() {
111 expect(tearDownRun, isFalse);
112 }, max: 1));
113
114 return _runTest(0).then((_) => expect(tearDownRun, isTrue));
115 });
116
117 test("can't be called multiple times", () {
118 _declarer.tearDown(() {});
119 expect(() => _declarer.tearDown(() {}), throwsStateError);
120 });
121 });
122
123 group("in a group,", () {
124 test("tests inherit the group's description", () {
125 _declarer.group("group", () {
126 _declarer.test("description", () {});
127 });
128
129 expect(_declarer.tests, hasLength(1));
130 expect(_declarer.tests.single.name, "group description");
131 });
132
133 group(".setUp()", () {
134 test("is scoped to the group", () {
135 var setUpRun = false;
136 _declarer.group("group", () {
137 _declarer.setUp(() => setUpRun = true);
138
139 _declarer.test("description 1", expectAsync(() {
140 expect(setUpRun, isTrue);
141 setUpRun = false;
142 }, max: 1));
143 });
144
145 _declarer.test("description 2", expectAsync(() {
146 expect(setUpRun, isFalse);
147 setUpRun = false;
148 }, max: 1));
149
150 return _runTest(0).then((_) => _runTest(1));
151 });
152
153 test("runs from the outside in", () {
154 var outerSetUpRun = false;
155 var middleSetUpRun = false;
156 var innerSetUpRun = false;
157 _declarer.setUp(expectAsync(() {
158 expect(middleSetUpRun, isFalse);
159 expect(innerSetUpRun, isFalse);
160 outerSetUpRun = true;
161 }, max: 1));
162
163 _declarer.group("middle", () {
164 _declarer.setUp(expectAsync(() {
165 expect(outerSetUpRun, isTrue);
166 expect(innerSetUpRun, isFalse);
167 middleSetUpRun = true;
168 }, max: 1));
169
170 _declarer.group("inner", () {
171 _declarer.setUp(expectAsync(() {
172 expect(outerSetUpRun, isTrue);
173 expect(middleSetUpRun, isTrue);
174 innerSetUpRun = true;
175 }, max: 1));
176
177 _declarer.test("description", expectAsync(() {
178 expect(outerSetUpRun, isTrue);
179 expect(middleSetUpRun, isTrue);
180 expect(innerSetUpRun, isTrue);
181 }, max: 1));
182 });
183 });
184
185 return _runTest(0);
186 });
187
188 test("handles Futures when chained", () {
189 var outerSetUpRun = false;
190 var innerSetUpRun = false;
191 _declarer.setUp(expectAsync(() {
192 expect(innerSetUpRun, isFalse);
193 return new Future(() => outerSetUpRun = true);
194 }, max: 1));
195
196 _declarer.group("inner", () {
197 _declarer.setUp(expectAsync(() {
198 expect(outerSetUpRun, isTrue);
199 return new Future(() => innerSetUpRun = true);
200 }, max: 1));
201
202 _declarer.test("description", expectAsync(() {
203 expect(outerSetUpRun, isTrue);
204 expect(innerSetUpRun, isTrue);
205 }, max: 1));
206 });
207
208 return _runTest(0);
209 });
210
211 test("can't be called multiple times", () {
212 _declarer.group("group", () {
213 _declarer.setUp(() {});
214 expect(() => _declarer.setUp(() {}), throwsStateError);
215 });
216 });
217 });
218
219 group(".tearDown()", () {
220 test("is scoped to the group", () {
221 var tearDownRun;
222 _declarer.setUp(() => tearDownRun = false);
223
224 _declarer.group("group", () {
225 _declarer.tearDown(() => tearDownRun = true);
226
227 _declarer.test("description 1", expectAsync(() {
228 expect(tearDownRun, isFalse);
229 }, max: 1));
230 });
231
232 _declarer.test("description 2", expectAsync(() {
233 expect(tearDownRun, isFalse);
234 }, max: 1));
235
236 return _runTest(0).then((_) {
237 expect(tearDownRun, isTrue);
238 return _runTest(1);
239 }).then((_) => expect(tearDownRun, isFalse));
240 });
241
242 test("runs from the inside out", () {
243 var innerTearDownRun = false;
244 var middleTearDownRun = false;
245 var outerTearDownRun = false;
246 _declarer.tearDown(expectAsync(() {
247 expect(innerTearDownRun, isTrue);
248 expect(middleTearDownRun, isTrue);
249 outerTearDownRun = true;
250 }, max: 1));
251
252 _declarer.group("middle", () {
253 _declarer.tearDown(expectAsync(() {
254 expect(innerTearDownRun, isTrue);
255 expect(outerTearDownRun, isFalse);
256 middleTearDownRun = true;
257 }, max: 1));
258
259 _declarer.group("inner", () {
260 _declarer.tearDown(expectAsync(() {
261 expect(outerTearDownRun, isFalse);
262 expect(middleTearDownRun, isFalse);
263 innerTearDownRun = true;
264 }, max: 1));
265
266 _declarer.test("description", expectAsync(() {
267 expect(outerTearDownRun, isFalse);
268 expect(middleTearDownRun, isFalse);
269 expect(innerTearDownRun, isFalse);
270 }, max: 1));
271 });
272 });
273
274 return _runTest(0).then((_) {
275 expect(innerTearDownRun, isTrue);
276 expect(middleTearDownRun, isTrue);
277 expect(outerTearDownRun, isTrue);
278 });
279 });
280
281 test("handles Futures when chained", () {
282 var outerTearDownRun = false;
283 var innerTearDownRun = false;
284 _declarer.tearDown(expectAsync(() {
285 expect(innerTearDownRun, isTrue);
286 return new Future(() => outerTearDownRun = true);
287 }, max: 1));
288
289 _declarer.group("inner", () {
290 _declarer.tearDown(expectAsync(() {
291 expect(outerTearDownRun, isFalse);
292 return new Future(() => innerTearDownRun = true);
293 }, max: 1));
294
295 _declarer.test("description", expectAsync(() {
296 expect(outerTearDownRun, isFalse);
297 expect(innerTearDownRun, isFalse);
298 }, max: 1));
299 });
300
301 return _runTest(0).then((_) {
302 expect(innerTearDownRun, isTrue);
303 expect(outerTearDownRun, isTrue);
304 });
305 });
306
307 test("can't be called multiple times", () {
308 _declarer.group("group", () {
309 _declarer.tearDown(() {});
310 expect(() => _declarer.tearDown(() {}), throwsStateError);
311 });
312 });
313 });
314 });
315 }
316
317 /// Runs the test at [index] defined on [_declarer].
318 ///
319 /// This automatically sets up an `onError` listener to ensure that the test
320 /// doesn't throw any invisible exceptions.
321 Future _runTest(int index) {
322 var liveTest = _declarer.tests[index].load(_suite);
323 liveTest.onError.listen(expectAsync((_) {},
324 count: 0, reason: "No errors expected for test #$index."));
325 return liveTest.run();
326 }
OLDNEW
« no previous file with comments | « test/compact_reporter_test.dart ('k') | test/engine_test.dart » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698