ava 0.15.0 → 0.17.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/api.js +243 -187
- package/cli.js +12 -187
- package/index.js +5 -98
- package/index.js.flow +218 -0
- package/lib/assert.js +11 -6
- package/lib/babel-config.js +152 -0
- package/lib/beautify-stack.js +23 -0
- package/lib/caching-precompiler.js +24 -115
- package/lib/cli.js +172 -0
- package/lib/colors.js +2 -0
- package/lib/concurrent.js +2 -3
- package/lib/enhance-assert.js +15 -6
- package/lib/fork.js +23 -15
- package/lib/logger.js +4 -5
- package/lib/main.js +89 -0
- package/lib/prefix-title.js +25 -0
- package/lib/process-adapter.js +107 -0
- package/lib/reporters/mini.js +32 -27
- package/lib/run-status.js +5 -36
- package/lib/runner.js +10 -0
- package/lib/sequence.js +2 -4
- package/lib/test-worker.js +13 -75
- package/lib/test.js +18 -5
- package/lib/throws-helper.js +6 -4
- package/lib/watcher.js +10 -18
- package/package.json +48 -29
- package/profile.js +15 -10
- package/readme.md +72 -43
- package/types/generated.d.ts +1667 -0
- package/types/make.js +166 -0
- package/index.d.ts +0 -206
- package/lib/ava-files.js +0 -262
- package/lib/send.js +0 -16
|
@@ -0,0 +1,1667 @@
|
|
|
1
|
+
export default test;
|
|
2
|
+
|
|
3
|
+
export type ErrorValidator
|
|
4
|
+
= (new (...args: any[]) => any)
|
|
5
|
+
| RegExp
|
|
6
|
+
| string
|
|
7
|
+
| ((error: any) => boolean);
|
|
8
|
+
|
|
9
|
+
export interface Observable {
|
|
10
|
+
subscribe(observer: (value: {}) => void): void;
|
|
11
|
+
}
|
|
12
|
+
|
|
13
|
+
export type Test = (t: TestContext) => PromiseLike<void> | Iterator<any> | Observable | void;
|
|
14
|
+
export type ContextualTest = (t: ContextualTestContext) => PromiseLike<void> | Iterator<any> | Observable | void;
|
|
15
|
+
export type CallbackTest = (t: CallbackTestContext) => void;
|
|
16
|
+
export type ContextualCallbackTest = (t: ContextualCallbackTestContext) => void;
|
|
17
|
+
|
|
18
|
+
export interface AssertContext {
|
|
19
|
+
/**
|
|
20
|
+
* Passing assertion.
|
|
21
|
+
*/
|
|
22
|
+
pass(message?: string): void;
|
|
23
|
+
/**
|
|
24
|
+
* Failing assertion.
|
|
25
|
+
*/
|
|
26
|
+
fail(message?: string): void;
|
|
27
|
+
/**
|
|
28
|
+
* Assert that value is truthy.
|
|
29
|
+
*/
|
|
30
|
+
truthy(value: any, message?: string): void;
|
|
31
|
+
/**
|
|
32
|
+
* Assert that value is falsy.
|
|
33
|
+
*/
|
|
34
|
+
falsy(value: any, message?: string): void;
|
|
35
|
+
/**
|
|
36
|
+
* DEPRECATED, use `truthy`. Assert that value is truthy.
|
|
37
|
+
*/
|
|
38
|
+
ok(value: any, message?: string): void;
|
|
39
|
+
/**
|
|
40
|
+
* DEPRECATED, use `falsy`. Assert that value is falsy.
|
|
41
|
+
*/
|
|
42
|
+
notOk(value: any, message?: string): void;
|
|
43
|
+
/**
|
|
44
|
+
* Assert that value is true.
|
|
45
|
+
*/
|
|
46
|
+
true(value: boolean, message?: string): void;
|
|
47
|
+
/**
|
|
48
|
+
* Assert that value is false.
|
|
49
|
+
*/
|
|
50
|
+
false(value: boolean, message?: string): void;
|
|
51
|
+
/**
|
|
52
|
+
* Assert that value is equal to expected.
|
|
53
|
+
*/
|
|
54
|
+
is<U>(value: U, expected: U, message?: string): void;
|
|
55
|
+
/**
|
|
56
|
+
* Assert that value is not equal to expected.
|
|
57
|
+
*/
|
|
58
|
+
not<U>(value: U, expected: U, message?: string): void;
|
|
59
|
+
/**
|
|
60
|
+
* Assert that value is deep equal to expected.
|
|
61
|
+
*/
|
|
62
|
+
deepEqual<U>(value: U, expected: U, message?: string): void;
|
|
63
|
+
/**
|
|
64
|
+
* Assert that value is not deep equal to expected.
|
|
65
|
+
*/
|
|
66
|
+
notDeepEqual<U>(value: U, expected: U, message?: string): void;
|
|
67
|
+
/**
|
|
68
|
+
* Assert that function throws an error or promise rejects.
|
|
69
|
+
* DEPRECATED, use `deepEqual`. Assert that value is deep equal to expected.
|
|
70
|
+
* @param error Can be a constructor, regex, error message or validation function.
|
|
71
|
+
*/
|
|
72
|
+
same<U>(value: U, expected: U, message?: string): void;
|
|
73
|
+
/**
|
|
74
|
+
* DEPRECATED use `notDeepEqual`. Assert that value is not deep equal to expected.
|
|
75
|
+
*/
|
|
76
|
+
notSame<U>(value: U, expected: U, message?: string): void;
|
|
77
|
+
/**
|
|
78
|
+
* Assert that function throws an error or promise rejects.
|
|
79
|
+
* @param error Can be a constructor, regex, error message or validation function.
|
|
80
|
+
*/
|
|
81
|
+
throws(value: PromiseLike<any>, error?: ErrorValidator, message?: string): Promise<any>;
|
|
82
|
+
throws(value: () => void, error?: ErrorValidator, message?: string): any;
|
|
83
|
+
/**
|
|
84
|
+
* Assert that function doesn't throw an error or promise resolves.
|
|
85
|
+
*/
|
|
86
|
+
notThrows<U>(value: PromiseLike<U>, message?: string): Promise<U>;
|
|
87
|
+
notThrows(value: () => void, message?: string): void;
|
|
88
|
+
/**
|
|
89
|
+
* Assert that contents matches regex.
|
|
90
|
+
*/
|
|
91
|
+
regex(contents: string, regex: RegExp, message?: string): void;
|
|
92
|
+
/**
|
|
93
|
+
* Assert that contents does not match regex.
|
|
94
|
+
*/
|
|
95
|
+
notRegex(contents: string, regex: RegExp, message?: string): void;
|
|
96
|
+
/**
|
|
97
|
+
* Assert that error is falsy.
|
|
98
|
+
*/
|
|
99
|
+
ifError(error: any, message?: string): void;
|
|
100
|
+
}
|
|
101
|
+
export interface TestContext extends AssertContext {
|
|
102
|
+
/**
|
|
103
|
+
* Plan how many assertion there are in the test.
|
|
104
|
+
* The test will fail if the actual assertion count doesn't match planned assertions.
|
|
105
|
+
*/
|
|
106
|
+
plan(count: number): void;
|
|
107
|
+
|
|
108
|
+
skip: AssertContext;
|
|
109
|
+
}
|
|
110
|
+
export interface CallbackTestContext extends TestContext {
|
|
111
|
+
/**
|
|
112
|
+
* End the test.
|
|
113
|
+
*/
|
|
114
|
+
end(): void;
|
|
115
|
+
}
|
|
116
|
+
export interface ContextualTestContext extends TestContext {
|
|
117
|
+
context: any;
|
|
118
|
+
}
|
|
119
|
+
export interface ContextualCallbackTestContext extends CallbackTestContext {
|
|
120
|
+
context: any;
|
|
121
|
+
}
|
|
122
|
+
|
|
123
|
+
export interface Macro<T> {
|
|
124
|
+
(t: T, ...args: any[]): void;
|
|
125
|
+
title? (providedTitle: string, ...args: any[]): string;
|
|
126
|
+
}
|
|
127
|
+
export type Macros<T> = Macro<T> | Macro<T>[];
|
|
128
|
+
|
|
129
|
+
export function test(name: string, run: ContextualTest): void;
|
|
130
|
+
export function test(run: ContextualTest): void;
|
|
131
|
+
export function test(name: string, run: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
132
|
+
export function test(run: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
133
|
+
export namespace test {
|
|
134
|
+
export function serial(name: string, implementation: ContextualTest): void;
|
|
135
|
+
export function serial(implementation: ContextualTest): void;
|
|
136
|
+
export function serial(name: string, implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
137
|
+
export function serial(implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
138
|
+
export function before(name: string, implementation: Test): void;
|
|
139
|
+
export function before(implementation: Test): void;
|
|
140
|
+
export function before(name: string, implementation: Macros<TestContext>, ...args: any[]): void;
|
|
141
|
+
export function before(implementation: Macros<TestContext>, ...args: any[]): void;
|
|
142
|
+
export function after(name: string, implementation: Test): void;
|
|
143
|
+
export function after(implementation: Test): void;
|
|
144
|
+
export function after(name: string, implementation: Macros<TestContext>, ...args: any[]): void;
|
|
145
|
+
export function after(implementation: Macros<TestContext>, ...args: any[]): void;
|
|
146
|
+
export function skip(name: string, implementation: ContextualTest): void;
|
|
147
|
+
export function skip(implementation: ContextualTest): void;
|
|
148
|
+
export function skip(name: string, implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
149
|
+
export function skip(implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
150
|
+
export function todo(name: string, implementation: ContextualTest): void;
|
|
151
|
+
export function todo(implementation: ContextualTest): void;
|
|
152
|
+
export function todo(name: string, implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
153
|
+
export function todo(implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
154
|
+
export function failing(name: string, implementation: ContextualTest): void;
|
|
155
|
+
export function failing(implementation: ContextualTest): void;
|
|
156
|
+
export function failing(name: string, implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
157
|
+
export function failing(implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
158
|
+
export function only(name: string, implementation: ContextualTest): void;
|
|
159
|
+
export function only(implementation: ContextualTest): void;
|
|
160
|
+
export function only(name: string, implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
161
|
+
export function only(implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
162
|
+
export function beforeEach(name: string, implementation: ContextualTest): void;
|
|
163
|
+
export function beforeEach(implementation: ContextualTest): void;
|
|
164
|
+
export function beforeEach(name: string, implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
165
|
+
export function beforeEach(implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
166
|
+
export function afterEach(name: string, implementation: ContextualTest): void;
|
|
167
|
+
export function afterEach(implementation: ContextualTest): void;
|
|
168
|
+
export function afterEach(name: string, implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
169
|
+
export function afterEach(implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
170
|
+
export function cb(name: string, implementation: ContextualCallbackTest): void;
|
|
171
|
+
export function cb(implementation: ContextualCallbackTest): void;
|
|
172
|
+
export function cb(name: string, implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
173
|
+
export function cb(implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
174
|
+
}
|
|
175
|
+
export namespace test.serial {
|
|
176
|
+
export const before: typeof test.before.serial;
|
|
177
|
+
export const after: typeof test.after.serial;
|
|
178
|
+
export function skip(name: string, implementation: ContextualTest): void;
|
|
179
|
+
export function skip(implementation: ContextualTest): void;
|
|
180
|
+
export function skip(name: string, implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
181
|
+
export function skip(implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
182
|
+
export function todo(name: string, implementation: ContextualTest): void;
|
|
183
|
+
export function todo(implementation: ContextualTest): void;
|
|
184
|
+
export function todo(name: string, implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
185
|
+
export function todo(implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
186
|
+
export const failing: typeof test.failing.serial;
|
|
187
|
+
export const only: typeof test.only.serial;
|
|
188
|
+
export const beforeEach: typeof test.beforeEach.serial;
|
|
189
|
+
export const afterEach: typeof test.afterEach.serial;
|
|
190
|
+
export const cb: typeof test.cb.serial;
|
|
191
|
+
export const always: typeof test.always.serial;
|
|
192
|
+
}
|
|
193
|
+
export namespace test.serial.skip {
|
|
194
|
+
export const before: typeof test.before.serial.skip;
|
|
195
|
+
export const after: typeof test.after.serial.skip;
|
|
196
|
+
export const failing: typeof test.failing.serial.skip;
|
|
197
|
+
export const beforeEach: typeof test.beforeEach.serial.skip;
|
|
198
|
+
export const afterEach: typeof test.afterEach.serial.skip;
|
|
199
|
+
export const cb: typeof test.cb.serial.skip;
|
|
200
|
+
export const always: typeof test.always.serial.skip;
|
|
201
|
+
}
|
|
202
|
+
export namespace test.serial.todo {
|
|
203
|
+
export const before: typeof test.before.serial.todo;
|
|
204
|
+
export const after: typeof test.after.serial.todo;
|
|
205
|
+
export const failing: typeof test.failing.serial.todo;
|
|
206
|
+
export const beforeEach: typeof test.beforeEach.serial.todo;
|
|
207
|
+
export const afterEach: typeof test.afterEach.serial.todo;
|
|
208
|
+
export const cb: typeof test.cb.serial.todo;
|
|
209
|
+
export const always: typeof test.always.serial.todo;
|
|
210
|
+
}
|
|
211
|
+
export namespace test.before {
|
|
212
|
+
export function serial(name: string, implementation: Test): void;
|
|
213
|
+
export function serial(implementation: Test): void;
|
|
214
|
+
export function serial(name: string, implementation: Macros<TestContext>, ...args: any[]): void;
|
|
215
|
+
export function serial(implementation: Macros<TestContext>, ...args: any[]): void;
|
|
216
|
+
export function skip(name: string, implementation: Test): void;
|
|
217
|
+
export function skip(implementation: Test): void;
|
|
218
|
+
export function skip(name: string, implementation: Macros<TestContext>, ...args: any[]): void;
|
|
219
|
+
export function skip(implementation: Macros<TestContext>, ...args: any[]): void;
|
|
220
|
+
export function todo(name: string, implementation: Test): void;
|
|
221
|
+
export function todo(implementation: Test): void;
|
|
222
|
+
export function todo(name: string, implementation: Macros<TestContext>, ...args: any[]): void;
|
|
223
|
+
export function todo(implementation: Macros<TestContext>, ...args: any[]): void;
|
|
224
|
+
export function failing(name: string, implementation: Test): void;
|
|
225
|
+
export function failing(implementation: Test): void;
|
|
226
|
+
export function failing(name: string, implementation: Macros<TestContext>, ...args: any[]): void;
|
|
227
|
+
export function failing(implementation: Macros<TestContext>, ...args: any[]): void;
|
|
228
|
+
export function cb(name: string, implementation: CallbackTest): void;
|
|
229
|
+
export function cb(implementation: CallbackTest): void;
|
|
230
|
+
export function cb(name: string, implementation: Macros<CallbackTestContext>, ...args: any[]): void;
|
|
231
|
+
export function cb(implementation: Macros<CallbackTestContext>, ...args: any[]): void;
|
|
232
|
+
}
|
|
233
|
+
export namespace test.before.serial {
|
|
234
|
+
export function skip(name: string, implementation: Test): void;
|
|
235
|
+
export function skip(implementation: Test): void;
|
|
236
|
+
export function skip(name: string, implementation: Macros<TestContext>, ...args: any[]): void;
|
|
237
|
+
export function skip(implementation: Macros<TestContext>, ...args: any[]): void;
|
|
238
|
+
export function todo(name: string, implementation: Test): void;
|
|
239
|
+
export function todo(implementation: Test): void;
|
|
240
|
+
export function todo(name: string, implementation: Macros<TestContext>, ...args: any[]): void;
|
|
241
|
+
export function todo(implementation: Macros<TestContext>, ...args: any[]): void;
|
|
242
|
+
export const failing: typeof test.before.failing.serial;
|
|
243
|
+
export const cb: typeof test.before.cb.serial;
|
|
244
|
+
}
|
|
245
|
+
export namespace test.before.serial.skip {
|
|
246
|
+
export const failing: typeof test.before.failing.serial.skip;
|
|
247
|
+
export const cb: typeof test.before.cb.serial.skip;
|
|
248
|
+
}
|
|
249
|
+
export namespace test.before.serial.todo {
|
|
250
|
+
export const failing: typeof test.before.failing.serial.todo;
|
|
251
|
+
export const cb: typeof test.before.cb.serial.todo;
|
|
252
|
+
}
|
|
253
|
+
export namespace test.before.skip {
|
|
254
|
+
export const serial: typeof test.before.serial.skip;
|
|
255
|
+
export const failing: typeof test.before.failing.skip;
|
|
256
|
+
export const cb: typeof test.before.cb.skip;
|
|
257
|
+
}
|
|
258
|
+
export namespace test.before.todo {
|
|
259
|
+
export const serial: typeof test.before.serial.todo;
|
|
260
|
+
export const failing: typeof test.before.failing.todo;
|
|
261
|
+
export const cb: typeof test.before.cb.todo;
|
|
262
|
+
}
|
|
263
|
+
export namespace test.before.failing {
|
|
264
|
+
export function serial(name: string, implementation: Test): void;
|
|
265
|
+
export function serial(implementation: Test): void;
|
|
266
|
+
export function serial(name: string, implementation: Macros<TestContext>, ...args: any[]): void;
|
|
267
|
+
export function serial(implementation: Macros<TestContext>, ...args: any[]): void;
|
|
268
|
+
export function skip(name: string, implementation: Test): void;
|
|
269
|
+
export function skip(implementation: Test): void;
|
|
270
|
+
export function skip(name: string, implementation: Macros<TestContext>, ...args: any[]): void;
|
|
271
|
+
export function skip(implementation: Macros<TestContext>, ...args: any[]): void;
|
|
272
|
+
export function todo(name: string, implementation: Test): void;
|
|
273
|
+
export function todo(implementation: Test): void;
|
|
274
|
+
export function todo(name: string, implementation: Macros<TestContext>, ...args: any[]): void;
|
|
275
|
+
export function todo(implementation: Macros<TestContext>, ...args: any[]): void;
|
|
276
|
+
export const cb: typeof test.before.cb.failing;
|
|
277
|
+
}
|
|
278
|
+
export namespace test.before.failing.serial {
|
|
279
|
+
export function skip(name: string, implementation: Test): void;
|
|
280
|
+
export function skip(implementation: Test): void;
|
|
281
|
+
export function skip(name: string, implementation: Macros<TestContext>, ...args: any[]): void;
|
|
282
|
+
export function skip(implementation: Macros<TestContext>, ...args: any[]): void;
|
|
283
|
+
export function todo(name: string, implementation: Test): void;
|
|
284
|
+
export function todo(implementation: Test): void;
|
|
285
|
+
export function todo(name: string, implementation: Macros<TestContext>, ...args: any[]): void;
|
|
286
|
+
export function todo(implementation: Macros<TestContext>, ...args: any[]): void;
|
|
287
|
+
export const cb: typeof test.before.cb.failing.serial;
|
|
288
|
+
}
|
|
289
|
+
export namespace test.before.failing.serial.skip {
|
|
290
|
+
export const cb: typeof test.before.cb.failing.serial.skip;
|
|
291
|
+
}
|
|
292
|
+
export namespace test.before.failing.serial.todo {
|
|
293
|
+
export const cb: typeof test.before.cb.failing.serial.todo;
|
|
294
|
+
}
|
|
295
|
+
export namespace test.before.failing.skip {
|
|
296
|
+
export const serial: typeof test.before.failing.serial.skip;
|
|
297
|
+
export const cb: typeof test.before.cb.failing.skip;
|
|
298
|
+
}
|
|
299
|
+
export namespace test.before.failing.todo {
|
|
300
|
+
export const serial: typeof test.before.failing.serial.todo;
|
|
301
|
+
export const cb: typeof test.before.cb.failing.todo;
|
|
302
|
+
}
|
|
303
|
+
export namespace test.before.cb {
|
|
304
|
+
export function serial(name: string, implementation: CallbackTest): void;
|
|
305
|
+
export function serial(implementation: CallbackTest): void;
|
|
306
|
+
export function serial(name: string, implementation: Macros<CallbackTestContext>, ...args: any[]): void;
|
|
307
|
+
export function serial(implementation: Macros<CallbackTestContext>, ...args: any[]): void;
|
|
308
|
+
export function skip(name: string, implementation: CallbackTest): void;
|
|
309
|
+
export function skip(implementation: CallbackTest): void;
|
|
310
|
+
export function skip(name: string, implementation: Macros<CallbackTestContext>, ...args: any[]): void;
|
|
311
|
+
export function skip(implementation: Macros<CallbackTestContext>, ...args: any[]): void;
|
|
312
|
+
export function todo(name: string, implementation: CallbackTest): void;
|
|
313
|
+
export function todo(implementation: CallbackTest): void;
|
|
314
|
+
export function todo(name: string, implementation: Macros<CallbackTestContext>, ...args: any[]): void;
|
|
315
|
+
export function todo(implementation: Macros<CallbackTestContext>, ...args: any[]): void;
|
|
316
|
+
export function failing(name: string, implementation: CallbackTest): void;
|
|
317
|
+
export function failing(implementation: CallbackTest): void;
|
|
318
|
+
export function failing(name: string, implementation: Macros<CallbackTestContext>, ...args: any[]): void;
|
|
319
|
+
export function failing(implementation: Macros<CallbackTestContext>, ...args: any[]): void;
|
|
320
|
+
}
|
|
321
|
+
export namespace test.before.cb.serial {
|
|
322
|
+
export function skip(name: string, implementation: CallbackTest): void;
|
|
323
|
+
export function skip(implementation: CallbackTest): void;
|
|
324
|
+
export function skip(name: string, implementation: Macros<CallbackTestContext>, ...args: any[]): void;
|
|
325
|
+
export function skip(implementation: Macros<CallbackTestContext>, ...args: any[]): void;
|
|
326
|
+
export function todo(name: string, implementation: CallbackTest): void;
|
|
327
|
+
export function todo(implementation: CallbackTest): void;
|
|
328
|
+
export function todo(name: string, implementation: Macros<CallbackTestContext>, ...args: any[]): void;
|
|
329
|
+
export function todo(implementation: Macros<CallbackTestContext>, ...args: any[]): void;
|
|
330
|
+
export const failing: typeof test.before.cb.failing.serial;
|
|
331
|
+
}
|
|
332
|
+
export namespace test.before.cb.serial.skip {
|
|
333
|
+
export const failing: typeof test.before.cb.failing.serial.skip;
|
|
334
|
+
}
|
|
335
|
+
export namespace test.before.cb.serial.todo {
|
|
336
|
+
export const failing: typeof test.before.cb.failing.serial.todo;
|
|
337
|
+
}
|
|
338
|
+
export namespace test.before.cb.skip {
|
|
339
|
+
export const serial: typeof test.before.cb.serial.skip;
|
|
340
|
+
export const failing: typeof test.before.cb.failing.skip;
|
|
341
|
+
}
|
|
342
|
+
export namespace test.before.cb.todo {
|
|
343
|
+
export const serial: typeof test.before.cb.serial.todo;
|
|
344
|
+
export const failing: typeof test.before.cb.failing.todo;
|
|
345
|
+
}
|
|
346
|
+
export namespace test.before.cb.failing {
|
|
347
|
+
export function serial(name: string, implementation: CallbackTest): void;
|
|
348
|
+
export function serial(implementation: CallbackTest): void;
|
|
349
|
+
export function serial(name: string, implementation: Macros<CallbackTestContext>, ...args: any[]): void;
|
|
350
|
+
export function serial(implementation: Macros<CallbackTestContext>, ...args: any[]): void;
|
|
351
|
+
export function skip(name: string, implementation: CallbackTest): void;
|
|
352
|
+
export function skip(implementation: CallbackTest): void;
|
|
353
|
+
export function skip(name: string, implementation: Macros<CallbackTestContext>, ...args: any[]): void;
|
|
354
|
+
export function skip(implementation: Macros<CallbackTestContext>, ...args: any[]): void;
|
|
355
|
+
export function todo(name: string, implementation: CallbackTest): void;
|
|
356
|
+
export function todo(implementation: CallbackTest): void;
|
|
357
|
+
export function todo(name: string, implementation: Macros<CallbackTestContext>, ...args: any[]): void;
|
|
358
|
+
export function todo(implementation: Macros<CallbackTestContext>, ...args: any[]): void;
|
|
359
|
+
}
|
|
360
|
+
export namespace test.before.cb.failing.serial {
|
|
361
|
+
export function skip(name: string, implementation: CallbackTest): void;
|
|
362
|
+
export function skip(implementation: CallbackTest): void;
|
|
363
|
+
export function skip(name: string, implementation: Macros<CallbackTestContext>, ...args: any[]): void;
|
|
364
|
+
export function skip(implementation: Macros<CallbackTestContext>, ...args: any[]): void;
|
|
365
|
+
export function todo(name: string, implementation: CallbackTest): void;
|
|
366
|
+
export function todo(implementation: CallbackTest): void;
|
|
367
|
+
export function todo(name: string, implementation: Macros<CallbackTestContext>, ...args: any[]): void;
|
|
368
|
+
export function todo(implementation: Macros<CallbackTestContext>, ...args: any[]): void;
|
|
369
|
+
}
|
|
370
|
+
export namespace test.before.cb.failing.skip {
|
|
371
|
+
export const serial: typeof test.before.cb.failing.serial.skip;
|
|
372
|
+
}
|
|
373
|
+
export namespace test.before.cb.failing.todo {
|
|
374
|
+
export const serial: typeof test.before.cb.failing.serial.todo;
|
|
375
|
+
}
|
|
376
|
+
export namespace test.after {
|
|
377
|
+
export function serial(name: string, implementation: Test): void;
|
|
378
|
+
export function serial(implementation: Test): void;
|
|
379
|
+
export function serial(name: string, implementation: Macros<TestContext>, ...args: any[]): void;
|
|
380
|
+
export function serial(implementation: Macros<TestContext>, ...args: any[]): void;
|
|
381
|
+
export function skip(name: string, implementation: Test): void;
|
|
382
|
+
export function skip(implementation: Test): void;
|
|
383
|
+
export function skip(name: string, implementation: Macros<TestContext>, ...args: any[]): void;
|
|
384
|
+
export function skip(implementation: Macros<TestContext>, ...args: any[]): void;
|
|
385
|
+
export function todo(name: string, implementation: Test): void;
|
|
386
|
+
export function todo(implementation: Test): void;
|
|
387
|
+
export function todo(name: string, implementation: Macros<TestContext>, ...args: any[]): void;
|
|
388
|
+
export function todo(implementation: Macros<TestContext>, ...args: any[]): void;
|
|
389
|
+
export function failing(name: string, implementation: Test): void;
|
|
390
|
+
export function failing(implementation: Test): void;
|
|
391
|
+
export function failing(name: string, implementation: Macros<TestContext>, ...args: any[]): void;
|
|
392
|
+
export function failing(implementation: Macros<TestContext>, ...args: any[]): void;
|
|
393
|
+
export function cb(name: string, implementation: CallbackTest): void;
|
|
394
|
+
export function cb(implementation: CallbackTest): void;
|
|
395
|
+
export function cb(name: string, implementation: Macros<CallbackTestContext>, ...args: any[]): void;
|
|
396
|
+
export function cb(implementation: Macros<CallbackTestContext>, ...args: any[]): void;
|
|
397
|
+
export function always(name: string, implementation: Test): void;
|
|
398
|
+
export function always(implementation: Test): void;
|
|
399
|
+
export function always(name: string, implementation: Macros<TestContext>, ...args: any[]): void;
|
|
400
|
+
export function always(implementation: Macros<TestContext>, ...args: any[]): void;
|
|
401
|
+
}
|
|
402
|
+
export namespace test.after.serial {
|
|
403
|
+
export function skip(name: string, implementation: Test): void;
|
|
404
|
+
export function skip(implementation: Test): void;
|
|
405
|
+
export function skip(name: string, implementation: Macros<TestContext>, ...args: any[]): void;
|
|
406
|
+
export function skip(implementation: Macros<TestContext>, ...args: any[]): void;
|
|
407
|
+
export function todo(name: string, implementation: Test): void;
|
|
408
|
+
export function todo(implementation: Test): void;
|
|
409
|
+
export function todo(name: string, implementation: Macros<TestContext>, ...args: any[]): void;
|
|
410
|
+
export function todo(implementation: Macros<TestContext>, ...args: any[]): void;
|
|
411
|
+
export const failing: typeof test.after.failing.serial;
|
|
412
|
+
export const cb: typeof test.after.cb.serial;
|
|
413
|
+
export const always: typeof test.after.always.serial;
|
|
414
|
+
}
|
|
415
|
+
export namespace test.after.serial.skip {
|
|
416
|
+
export const failing: typeof test.after.failing.serial.skip;
|
|
417
|
+
export const cb: typeof test.after.cb.serial.skip;
|
|
418
|
+
export const always: typeof test.after.always.serial.skip;
|
|
419
|
+
}
|
|
420
|
+
export namespace test.after.serial.todo {
|
|
421
|
+
export const failing: typeof test.after.failing.serial.todo;
|
|
422
|
+
export const cb: typeof test.after.cb.serial.todo;
|
|
423
|
+
export const always: typeof test.after.always.serial.todo;
|
|
424
|
+
}
|
|
425
|
+
export namespace test.after.skip {
|
|
426
|
+
export const serial: typeof test.after.serial.skip;
|
|
427
|
+
export const failing: typeof test.after.failing.skip;
|
|
428
|
+
export const cb: typeof test.after.cb.skip;
|
|
429
|
+
export const always: typeof test.after.always.skip;
|
|
430
|
+
}
|
|
431
|
+
export namespace test.after.todo {
|
|
432
|
+
export const serial: typeof test.after.serial.todo;
|
|
433
|
+
export const failing: typeof test.after.failing.todo;
|
|
434
|
+
export const cb: typeof test.after.cb.todo;
|
|
435
|
+
export const always: typeof test.after.always.todo;
|
|
436
|
+
}
|
|
437
|
+
export namespace test.after.failing {
|
|
438
|
+
export function serial(name: string, implementation: Test): void;
|
|
439
|
+
export function serial(implementation: Test): void;
|
|
440
|
+
export function serial(name: string, implementation: Macros<TestContext>, ...args: any[]): void;
|
|
441
|
+
export function serial(implementation: Macros<TestContext>, ...args: any[]): void;
|
|
442
|
+
export function skip(name: string, implementation: Test): void;
|
|
443
|
+
export function skip(implementation: Test): void;
|
|
444
|
+
export function skip(name: string, implementation: Macros<TestContext>, ...args: any[]): void;
|
|
445
|
+
export function skip(implementation: Macros<TestContext>, ...args: any[]): void;
|
|
446
|
+
export function todo(name: string, implementation: Test): void;
|
|
447
|
+
export function todo(implementation: Test): void;
|
|
448
|
+
export function todo(name: string, implementation: Macros<TestContext>, ...args: any[]): void;
|
|
449
|
+
export function todo(implementation: Macros<TestContext>, ...args: any[]): void;
|
|
450
|
+
export const cb: typeof test.after.cb.failing;
|
|
451
|
+
export const always: typeof test.after.always.failing;
|
|
452
|
+
}
|
|
453
|
+
export namespace test.after.failing.serial {
|
|
454
|
+
export function skip(name: string, implementation: Test): void;
|
|
455
|
+
export function skip(implementation: Test): void;
|
|
456
|
+
export function skip(name: string, implementation: Macros<TestContext>, ...args: any[]): void;
|
|
457
|
+
export function skip(implementation: Macros<TestContext>, ...args: any[]): void;
|
|
458
|
+
export function todo(name: string, implementation: Test): void;
|
|
459
|
+
export function todo(implementation: Test): void;
|
|
460
|
+
export function todo(name: string, implementation: Macros<TestContext>, ...args: any[]): void;
|
|
461
|
+
export function todo(implementation: Macros<TestContext>, ...args: any[]): void;
|
|
462
|
+
export const cb: typeof test.after.cb.failing.serial;
|
|
463
|
+
export const always: typeof test.after.always.failing.serial;
|
|
464
|
+
}
|
|
465
|
+
export namespace test.after.failing.serial.skip {
|
|
466
|
+
export const cb: typeof test.after.cb.failing.serial.skip;
|
|
467
|
+
export const always: typeof test.after.always.failing.serial.skip;
|
|
468
|
+
}
|
|
469
|
+
export namespace test.after.failing.serial.todo {
|
|
470
|
+
export const cb: typeof test.after.cb.failing.serial.todo;
|
|
471
|
+
export const always: typeof test.after.always.failing.serial.todo;
|
|
472
|
+
}
|
|
473
|
+
export namespace test.after.failing.skip {
|
|
474
|
+
export const serial: typeof test.after.failing.serial.skip;
|
|
475
|
+
export const cb: typeof test.after.cb.failing.skip;
|
|
476
|
+
export const always: typeof test.after.always.failing.skip;
|
|
477
|
+
}
|
|
478
|
+
export namespace test.after.failing.todo {
|
|
479
|
+
export const serial: typeof test.after.failing.serial.todo;
|
|
480
|
+
export const cb: typeof test.after.cb.failing.todo;
|
|
481
|
+
export const always: typeof test.after.always.failing.todo;
|
|
482
|
+
}
|
|
483
|
+
export namespace test.after.cb {
|
|
484
|
+
export function serial(name: string, implementation: CallbackTest): void;
|
|
485
|
+
export function serial(implementation: CallbackTest): void;
|
|
486
|
+
export function serial(name: string, implementation: Macros<CallbackTestContext>, ...args: any[]): void;
|
|
487
|
+
export function serial(implementation: Macros<CallbackTestContext>, ...args: any[]): void;
|
|
488
|
+
export function skip(name: string, implementation: CallbackTest): void;
|
|
489
|
+
export function skip(implementation: CallbackTest): void;
|
|
490
|
+
export function skip(name: string, implementation: Macros<CallbackTestContext>, ...args: any[]): void;
|
|
491
|
+
export function skip(implementation: Macros<CallbackTestContext>, ...args: any[]): void;
|
|
492
|
+
export function todo(name: string, implementation: CallbackTest): void;
|
|
493
|
+
export function todo(implementation: CallbackTest): void;
|
|
494
|
+
export function todo(name: string, implementation: Macros<CallbackTestContext>, ...args: any[]): void;
|
|
495
|
+
export function todo(implementation: Macros<CallbackTestContext>, ...args: any[]): void;
|
|
496
|
+
export function failing(name: string, implementation: CallbackTest): void;
|
|
497
|
+
export function failing(implementation: CallbackTest): void;
|
|
498
|
+
export function failing(name: string, implementation: Macros<CallbackTestContext>, ...args: any[]): void;
|
|
499
|
+
export function failing(implementation: Macros<CallbackTestContext>, ...args: any[]): void;
|
|
500
|
+
export const always: typeof test.after.always.cb;
|
|
501
|
+
}
|
|
502
|
+
export namespace test.after.cb.serial {
|
|
503
|
+
export function skip(name: string, implementation: CallbackTest): void;
|
|
504
|
+
export function skip(implementation: CallbackTest): void;
|
|
505
|
+
export function skip(name: string, implementation: Macros<CallbackTestContext>, ...args: any[]): void;
|
|
506
|
+
export function skip(implementation: Macros<CallbackTestContext>, ...args: any[]): void;
|
|
507
|
+
export function todo(name: string, implementation: CallbackTest): void;
|
|
508
|
+
export function todo(implementation: CallbackTest): void;
|
|
509
|
+
export function todo(name: string, implementation: Macros<CallbackTestContext>, ...args: any[]): void;
|
|
510
|
+
export function todo(implementation: Macros<CallbackTestContext>, ...args: any[]): void;
|
|
511
|
+
export const failing: typeof test.after.cb.failing.serial;
|
|
512
|
+
export const always: typeof test.after.always.cb.serial;
|
|
513
|
+
}
|
|
514
|
+
export namespace test.after.cb.serial.skip {
|
|
515
|
+
export const failing: typeof test.after.cb.failing.serial.skip;
|
|
516
|
+
export const always: typeof test.after.always.cb.serial.skip;
|
|
517
|
+
}
|
|
518
|
+
export namespace test.after.cb.serial.todo {
|
|
519
|
+
export const failing: typeof test.after.cb.failing.serial.todo;
|
|
520
|
+
export const always: typeof test.after.always.cb.serial.todo;
|
|
521
|
+
}
|
|
522
|
+
export namespace test.after.cb.skip {
|
|
523
|
+
export const serial: typeof test.after.cb.serial.skip;
|
|
524
|
+
export const failing: typeof test.after.cb.failing.skip;
|
|
525
|
+
export const always: typeof test.after.always.cb.skip;
|
|
526
|
+
}
|
|
527
|
+
export namespace test.after.cb.todo {
|
|
528
|
+
export const serial: typeof test.after.cb.serial.todo;
|
|
529
|
+
export const failing: typeof test.after.cb.failing.todo;
|
|
530
|
+
export const always: typeof test.after.always.cb.todo;
|
|
531
|
+
}
|
|
532
|
+
export namespace test.after.cb.failing {
|
|
533
|
+
export function serial(name: string, implementation: CallbackTest): void;
|
|
534
|
+
export function serial(implementation: CallbackTest): void;
|
|
535
|
+
export function serial(name: string, implementation: Macros<CallbackTestContext>, ...args: any[]): void;
|
|
536
|
+
export function serial(implementation: Macros<CallbackTestContext>, ...args: any[]): void;
|
|
537
|
+
export function skip(name: string, implementation: CallbackTest): void;
|
|
538
|
+
export function skip(implementation: CallbackTest): void;
|
|
539
|
+
export function skip(name: string, implementation: Macros<CallbackTestContext>, ...args: any[]): void;
|
|
540
|
+
export function skip(implementation: Macros<CallbackTestContext>, ...args: any[]): void;
|
|
541
|
+
export function todo(name: string, implementation: CallbackTest): void;
|
|
542
|
+
export function todo(implementation: CallbackTest): void;
|
|
543
|
+
export function todo(name: string, implementation: Macros<CallbackTestContext>, ...args: any[]): void;
|
|
544
|
+
export function todo(implementation: Macros<CallbackTestContext>, ...args: any[]): void;
|
|
545
|
+
export const always: typeof test.after.always.cb.failing;
|
|
546
|
+
}
|
|
547
|
+
export namespace test.after.cb.failing.serial {
|
|
548
|
+
export function skip(name: string, implementation: CallbackTest): void;
|
|
549
|
+
export function skip(implementation: CallbackTest): void;
|
|
550
|
+
export function skip(name: string, implementation: Macros<CallbackTestContext>, ...args: any[]): void;
|
|
551
|
+
export function skip(implementation: Macros<CallbackTestContext>, ...args: any[]): void;
|
|
552
|
+
export function todo(name: string, implementation: CallbackTest): void;
|
|
553
|
+
export function todo(implementation: CallbackTest): void;
|
|
554
|
+
export function todo(name: string, implementation: Macros<CallbackTestContext>, ...args: any[]): void;
|
|
555
|
+
export function todo(implementation: Macros<CallbackTestContext>, ...args: any[]): void;
|
|
556
|
+
export const always: typeof test.after.always.cb.failing.serial;
|
|
557
|
+
}
|
|
558
|
+
export namespace test.after.cb.failing.serial.skip {
|
|
559
|
+
export const always: typeof test.after.always.cb.failing.serial.skip;
|
|
560
|
+
}
|
|
561
|
+
export namespace test.after.cb.failing.serial.todo {
|
|
562
|
+
export const always: typeof test.after.always.cb.failing.serial.todo;
|
|
563
|
+
}
|
|
564
|
+
export namespace test.after.cb.failing.skip {
|
|
565
|
+
export const serial: typeof test.after.cb.failing.serial.skip;
|
|
566
|
+
export const always: typeof test.after.always.cb.failing.skip;
|
|
567
|
+
}
|
|
568
|
+
export namespace test.after.cb.failing.todo {
|
|
569
|
+
export const serial: typeof test.after.cb.failing.serial.todo;
|
|
570
|
+
export const always: typeof test.after.always.cb.failing.todo;
|
|
571
|
+
}
|
|
572
|
+
export namespace test.after.always {
|
|
573
|
+
export function serial(name: string, implementation: Test): void;
|
|
574
|
+
export function serial(implementation: Test): void;
|
|
575
|
+
export function serial(name: string, implementation: Macros<TestContext>, ...args: any[]): void;
|
|
576
|
+
export function serial(implementation: Macros<TestContext>, ...args: any[]): void;
|
|
577
|
+
export function skip(name: string, implementation: Test): void;
|
|
578
|
+
export function skip(implementation: Test): void;
|
|
579
|
+
export function skip(name: string, implementation: Macros<TestContext>, ...args: any[]): void;
|
|
580
|
+
export function skip(implementation: Macros<TestContext>, ...args: any[]): void;
|
|
581
|
+
export function todo(name: string, implementation: Test): void;
|
|
582
|
+
export function todo(implementation: Test): void;
|
|
583
|
+
export function todo(name: string, implementation: Macros<TestContext>, ...args: any[]): void;
|
|
584
|
+
export function todo(implementation: Macros<TestContext>, ...args: any[]): void;
|
|
585
|
+
export function failing(name: string, implementation: Test): void;
|
|
586
|
+
export function failing(implementation: Test): void;
|
|
587
|
+
export function failing(name: string, implementation: Macros<TestContext>, ...args: any[]): void;
|
|
588
|
+
export function failing(implementation: Macros<TestContext>, ...args: any[]): void;
|
|
589
|
+
export function cb(name: string, implementation: CallbackTest): void;
|
|
590
|
+
export function cb(implementation: CallbackTest): void;
|
|
591
|
+
export function cb(name: string, implementation: Macros<CallbackTestContext>, ...args: any[]): void;
|
|
592
|
+
export function cb(implementation: Macros<CallbackTestContext>, ...args: any[]): void;
|
|
593
|
+
}
|
|
594
|
+
export namespace test.after.always.serial {
|
|
595
|
+
export function skip(name: string, implementation: Test): void;
|
|
596
|
+
export function skip(implementation: Test): void;
|
|
597
|
+
export function skip(name: string, implementation: Macros<TestContext>, ...args: any[]): void;
|
|
598
|
+
export function skip(implementation: Macros<TestContext>, ...args: any[]): void;
|
|
599
|
+
export function todo(name: string, implementation: Test): void;
|
|
600
|
+
export function todo(implementation: Test): void;
|
|
601
|
+
export function todo(name: string, implementation: Macros<TestContext>, ...args: any[]): void;
|
|
602
|
+
export function todo(implementation: Macros<TestContext>, ...args: any[]): void;
|
|
603
|
+
export const failing: typeof test.after.always.failing.serial;
|
|
604
|
+
export const cb: typeof test.after.always.cb.serial;
|
|
605
|
+
}
|
|
606
|
+
export namespace test.after.always.serial.skip {
|
|
607
|
+
export const failing: typeof test.after.always.failing.serial.skip;
|
|
608
|
+
export const cb: typeof test.after.always.cb.serial.skip;
|
|
609
|
+
}
|
|
610
|
+
export namespace test.after.always.serial.todo {
|
|
611
|
+
export const failing: typeof test.after.always.failing.serial.todo;
|
|
612
|
+
export const cb: typeof test.after.always.cb.serial.todo;
|
|
613
|
+
}
|
|
614
|
+
export namespace test.after.always.skip {
|
|
615
|
+
export const serial: typeof test.after.always.serial.skip;
|
|
616
|
+
export const failing: typeof test.after.always.failing.skip;
|
|
617
|
+
export const cb: typeof test.after.always.cb.skip;
|
|
618
|
+
}
|
|
619
|
+
export namespace test.after.always.todo {
|
|
620
|
+
export const serial: typeof test.after.always.serial.todo;
|
|
621
|
+
export const failing: typeof test.after.always.failing.todo;
|
|
622
|
+
export const cb: typeof test.after.always.cb.todo;
|
|
623
|
+
}
|
|
624
|
+
export namespace test.after.always.failing {
|
|
625
|
+
export function serial(name: string, implementation: Test): void;
|
|
626
|
+
export function serial(implementation: Test): void;
|
|
627
|
+
export function serial(name: string, implementation: Macros<TestContext>, ...args: any[]): void;
|
|
628
|
+
export function serial(implementation: Macros<TestContext>, ...args: any[]): void;
|
|
629
|
+
export function skip(name: string, implementation: Test): void;
|
|
630
|
+
export function skip(implementation: Test): void;
|
|
631
|
+
export function skip(name: string, implementation: Macros<TestContext>, ...args: any[]): void;
|
|
632
|
+
export function skip(implementation: Macros<TestContext>, ...args: any[]): void;
|
|
633
|
+
export function todo(name: string, implementation: Test): void;
|
|
634
|
+
export function todo(implementation: Test): void;
|
|
635
|
+
export function todo(name: string, implementation: Macros<TestContext>, ...args: any[]): void;
|
|
636
|
+
export function todo(implementation: Macros<TestContext>, ...args: any[]): void;
|
|
637
|
+
export const cb: typeof test.after.always.cb.failing;
|
|
638
|
+
}
|
|
639
|
+
export namespace test.after.always.failing.serial {
|
|
640
|
+
export function skip(name: string, implementation: Test): void;
|
|
641
|
+
export function skip(implementation: Test): void;
|
|
642
|
+
export function skip(name: string, implementation: Macros<TestContext>, ...args: any[]): void;
|
|
643
|
+
export function skip(implementation: Macros<TestContext>, ...args: any[]): void;
|
|
644
|
+
export function todo(name: string, implementation: Test): void;
|
|
645
|
+
export function todo(implementation: Test): void;
|
|
646
|
+
export function todo(name: string, implementation: Macros<TestContext>, ...args: any[]): void;
|
|
647
|
+
export function todo(implementation: Macros<TestContext>, ...args: any[]): void;
|
|
648
|
+
export const cb: typeof test.after.always.cb.failing.serial;
|
|
649
|
+
}
|
|
650
|
+
export namespace test.after.always.failing.serial.skip {
|
|
651
|
+
export const cb: typeof test.after.always.cb.failing.serial.skip;
|
|
652
|
+
}
|
|
653
|
+
export namespace test.after.always.failing.serial.todo {
|
|
654
|
+
export const cb: typeof test.after.always.cb.failing.serial.todo;
|
|
655
|
+
}
|
|
656
|
+
export namespace test.after.always.failing.skip {
|
|
657
|
+
export const serial: typeof test.after.always.failing.serial.skip;
|
|
658
|
+
export const cb: typeof test.after.always.cb.failing.skip;
|
|
659
|
+
}
|
|
660
|
+
export namespace test.after.always.failing.todo {
|
|
661
|
+
export const serial: typeof test.after.always.failing.serial.todo;
|
|
662
|
+
export const cb: typeof test.after.always.cb.failing.todo;
|
|
663
|
+
}
|
|
664
|
+
export namespace test.after.always.cb {
|
|
665
|
+
export function serial(name: string, implementation: CallbackTest): void;
|
|
666
|
+
export function serial(implementation: CallbackTest): void;
|
|
667
|
+
export function serial(name: string, implementation: Macros<CallbackTestContext>, ...args: any[]): void;
|
|
668
|
+
export function serial(implementation: Macros<CallbackTestContext>, ...args: any[]): void;
|
|
669
|
+
export function skip(name: string, implementation: CallbackTest): void;
|
|
670
|
+
export function skip(implementation: CallbackTest): void;
|
|
671
|
+
export function skip(name: string, implementation: Macros<CallbackTestContext>, ...args: any[]): void;
|
|
672
|
+
export function skip(implementation: Macros<CallbackTestContext>, ...args: any[]): void;
|
|
673
|
+
export function todo(name: string, implementation: CallbackTest): void;
|
|
674
|
+
export function todo(implementation: CallbackTest): void;
|
|
675
|
+
export function todo(name: string, implementation: Macros<CallbackTestContext>, ...args: any[]): void;
|
|
676
|
+
export function todo(implementation: Macros<CallbackTestContext>, ...args: any[]): void;
|
|
677
|
+
export function failing(name: string, implementation: CallbackTest): void;
|
|
678
|
+
export function failing(implementation: CallbackTest): void;
|
|
679
|
+
export function failing(name: string, implementation: Macros<CallbackTestContext>, ...args: any[]): void;
|
|
680
|
+
export function failing(implementation: Macros<CallbackTestContext>, ...args: any[]): void;
|
|
681
|
+
}
|
|
682
|
+
export namespace test.after.always.cb.serial {
|
|
683
|
+
export function skip(name: string, implementation: CallbackTest): void;
|
|
684
|
+
export function skip(implementation: CallbackTest): void;
|
|
685
|
+
export function skip(name: string, implementation: Macros<CallbackTestContext>, ...args: any[]): void;
|
|
686
|
+
export function skip(implementation: Macros<CallbackTestContext>, ...args: any[]): void;
|
|
687
|
+
export function todo(name: string, implementation: CallbackTest): void;
|
|
688
|
+
export function todo(implementation: CallbackTest): void;
|
|
689
|
+
export function todo(name: string, implementation: Macros<CallbackTestContext>, ...args: any[]): void;
|
|
690
|
+
export function todo(implementation: Macros<CallbackTestContext>, ...args: any[]): void;
|
|
691
|
+
export const failing: typeof test.after.always.cb.failing.serial;
|
|
692
|
+
}
|
|
693
|
+
export namespace test.after.always.cb.serial.skip {
|
|
694
|
+
export const failing: typeof test.after.always.cb.failing.serial.skip;
|
|
695
|
+
}
|
|
696
|
+
export namespace test.after.always.cb.serial.todo {
|
|
697
|
+
export const failing: typeof test.after.always.cb.failing.serial.todo;
|
|
698
|
+
}
|
|
699
|
+
export namespace test.after.always.cb.skip {
|
|
700
|
+
export const serial: typeof test.after.always.cb.serial.skip;
|
|
701
|
+
export const failing: typeof test.after.always.cb.failing.skip;
|
|
702
|
+
}
|
|
703
|
+
export namespace test.after.always.cb.todo {
|
|
704
|
+
export const serial: typeof test.after.always.cb.serial.todo;
|
|
705
|
+
export const failing: typeof test.after.always.cb.failing.todo;
|
|
706
|
+
}
|
|
707
|
+
export namespace test.after.always.cb.failing {
|
|
708
|
+
export function serial(name: string, implementation: CallbackTest): void;
|
|
709
|
+
export function serial(implementation: CallbackTest): void;
|
|
710
|
+
export function serial(name: string, implementation: Macros<CallbackTestContext>, ...args: any[]): void;
|
|
711
|
+
export function serial(implementation: Macros<CallbackTestContext>, ...args: any[]): void;
|
|
712
|
+
export function skip(name: string, implementation: CallbackTest): void;
|
|
713
|
+
export function skip(implementation: CallbackTest): void;
|
|
714
|
+
export function skip(name: string, implementation: Macros<CallbackTestContext>, ...args: any[]): void;
|
|
715
|
+
export function skip(implementation: Macros<CallbackTestContext>, ...args: any[]): void;
|
|
716
|
+
export function todo(name: string, implementation: CallbackTest): void;
|
|
717
|
+
export function todo(implementation: CallbackTest): void;
|
|
718
|
+
export function todo(name: string, implementation: Macros<CallbackTestContext>, ...args: any[]): void;
|
|
719
|
+
export function todo(implementation: Macros<CallbackTestContext>, ...args: any[]): void;
|
|
720
|
+
}
|
|
721
|
+
export namespace test.after.always.cb.failing.serial {
|
|
722
|
+
export function skip(name: string, implementation: CallbackTest): void;
|
|
723
|
+
export function skip(implementation: CallbackTest): void;
|
|
724
|
+
export function skip(name: string, implementation: Macros<CallbackTestContext>, ...args: any[]): void;
|
|
725
|
+
export function skip(implementation: Macros<CallbackTestContext>, ...args: any[]): void;
|
|
726
|
+
export function todo(name: string, implementation: CallbackTest): void;
|
|
727
|
+
export function todo(implementation: CallbackTest): void;
|
|
728
|
+
export function todo(name: string, implementation: Macros<CallbackTestContext>, ...args: any[]): void;
|
|
729
|
+
export function todo(implementation: Macros<CallbackTestContext>, ...args: any[]): void;
|
|
730
|
+
}
|
|
731
|
+
export namespace test.after.always.cb.failing.skip {
|
|
732
|
+
export const serial: typeof test.after.always.cb.failing.serial.skip;
|
|
733
|
+
}
|
|
734
|
+
export namespace test.after.always.cb.failing.todo {
|
|
735
|
+
export const serial: typeof test.after.always.cb.failing.serial.todo;
|
|
736
|
+
}
|
|
737
|
+
export namespace test.skip {
|
|
738
|
+
export const serial: typeof test.serial.skip;
|
|
739
|
+
export const before: typeof test.before.skip;
|
|
740
|
+
export const after: typeof test.after.skip;
|
|
741
|
+
export const failing: typeof test.failing.skip;
|
|
742
|
+
export const beforeEach: typeof test.beforeEach.skip;
|
|
743
|
+
export const afterEach: typeof test.afterEach.skip;
|
|
744
|
+
export const cb: typeof test.cb.skip;
|
|
745
|
+
export const always: typeof test.always.skip;
|
|
746
|
+
}
|
|
747
|
+
export namespace test.todo {
|
|
748
|
+
export const serial: typeof test.serial.todo;
|
|
749
|
+
export const before: typeof test.before.todo;
|
|
750
|
+
export const after: typeof test.after.todo;
|
|
751
|
+
export const failing: typeof test.failing.todo;
|
|
752
|
+
export const beforeEach: typeof test.beforeEach.todo;
|
|
753
|
+
export const afterEach: typeof test.afterEach.todo;
|
|
754
|
+
export const cb: typeof test.cb.todo;
|
|
755
|
+
export const always: typeof test.always.todo;
|
|
756
|
+
}
|
|
757
|
+
export namespace test.failing {
|
|
758
|
+
export function serial(name: string, implementation: ContextualTest): void;
|
|
759
|
+
export function serial(implementation: ContextualTest): void;
|
|
760
|
+
export function serial(name: string, implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
761
|
+
export function serial(implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
762
|
+
export const before: typeof test.before.failing;
|
|
763
|
+
export const after: typeof test.after.failing;
|
|
764
|
+
export function skip(name: string, implementation: ContextualTest): void;
|
|
765
|
+
export function skip(implementation: ContextualTest): void;
|
|
766
|
+
export function skip(name: string, implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
767
|
+
export function skip(implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
768
|
+
export function todo(name: string, implementation: ContextualTest): void;
|
|
769
|
+
export function todo(implementation: ContextualTest): void;
|
|
770
|
+
export function todo(name: string, implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
771
|
+
export function todo(implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
772
|
+
export function only(name: string, implementation: ContextualTest): void;
|
|
773
|
+
export function only(implementation: ContextualTest): void;
|
|
774
|
+
export function only(name: string, implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
775
|
+
export function only(implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
776
|
+
export const beforeEach: typeof test.beforeEach.failing;
|
|
777
|
+
export const afterEach: typeof test.afterEach.failing;
|
|
778
|
+
export const cb: typeof test.cb.failing;
|
|
779
|
+
export const always: typeof test.always.failing;
|
|
780
|
+
}
|
|
781
|
+
export namespace test.failing.serial {
|
|
782
|
+
export const before: typeof test.before.failing.serial;
|
|
783
|
+
export const after: typeof test.after.failing.serial;
|
|
784
|
+
export function skip(name: string, implementation: ContextualTest): void;
|
|
785
|
+
export function skip(implementation: ContextualTest): void;
|
|
786
|
+
export function skip(name: string, implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
787
|
+
export function skip(implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
788
|
+
export function todo(name: string, implementation: ContextualTest): void;
|
|
789
|
+
export function todo(implementation: ContextualTest): void;
|
|
790
|
+
export function todo(name: string, implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
791
|
+
export function todo(implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
792
|
+
export const only: typeof test.failing.only.serial;
|
|
793
|
+
export const beforeEach: typeof test.beforeEach.failing.serial;
|
|
794
|
+
export const afterEach: typeof test.afterEach.failing.serial;
|
|
795
|
+
export const cb: typeof test.cb.failing.serial;
|
|
796
|
+
export const always: typeof test.always.failing.serial;
|
|
797
|
+
}
|
|
798
|
+
export namespace test.failing.serial.skip {
|
|
799
|
+
export const before: typeof test.before.failing.serial.skip;
|
|
800
|
+
export const after: typeof test.after.failing.serial.skip;
|
|
801
|
+
export const beforeEach: typeof test.beforeEach.failing.serial.skip;
|
|
802
|
+
export const afterEach: typeof test.afterEach.failing.serial.skip;
|
|
803
|
+
export const cb: typeof test.cb.failing.serial.skip;
|
|
804
|
+
export const always: typeof test.always.failing.serial.skip;
|
|
805
|
+
}
|
|
806
|
+
export namespace test.failing.serial.todo {
|
|
807
|
+
export const before: typeof test.before.failing.serial.todo;
|
|
808
|
+
export const after: typeof test.after.failing.serial.todo;
|
|
809
|
+
export const beforeEach: typeof test.beforeEach.failing.serial.todo;
|
|
810
|
+
export const afterEach: typeof test.afterEach.failing.serial.todo;
|
|
811
|
+
export const cb: typeof test.cb.failing.serial.todo;
|
|
812
|
+
export const always: typeof test.always.failing.serial.todo;
|
|
813
|
+
}
|
|
814
|
+
export namespace test.failing.skip {
|
|
815
|
+
export const serial: typeof test.failing.serial.skip;
|
|
816
|
+
export const before: typeof test.before.failing.skip;
|
|
817
|
+
export const after: typeof test.after.failing.skip;
|
|
818
|
+
export const beforeEach: typeof test.beforeEach.failing.skip;
|
|
819
|
+
export const afterEach: typeof test.afterEach.failing.skip;
|
|
820
|
+
export const cb: typeof test.cb.failing.skip;
|
|
821
|
+
export const always: typeof test.always.failing.skip;
|
|
822
|
+
}
|
|
823
|
+
export namespace test.failing.todo {
|
|
824
|
+
export const serial: typeof test.failing.serial.todo;
|
|
825
|
+
export const before: typeof test.before.failing.todo;
|
|
826
|
+
export const after: typeof test.after.failing.todo;
|
|
827
|
+
export const beforeEach: typeof test.beforeEach.failing.todo;
|
|
828
|
+
export const afterEach: typeof test.afterEach.failing.todo;
|
|
829
|
+
export const cb: typeof test.cb.failing.todo;
|
|
830
|
+
export const always: typeof test.always.failing.todo;
|
|
831
|
+
}
|
|
832
|
+
export namespace test.failing.only {
|
|
833
|
+
export function serial(name: string, implementation: ContextualTest): void;
|
|
834
|
+
export function serial(implementation: ContextualTest): void;
|
|
835
|
+
export function serial(name: string, implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
836
|
+
export function serial(implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
837
|
+
export const cb: typeof test.cb.failing.only;
|
|
838
|
+
}
|
|
839
|
+
export namespace test.failing.only.serial {
|
|
840
|
+
export const cb: typeof test.cb.failing.only.serial;
|
|
841
|
+
}
|
|
842
|
+
export namespace test.only {
|
|
843
|
+
export function serial(name: string, implementation: ContextualTest): void;
|
|
844
|
+
export function serial(implementation: ContextualTest): void;
|
|
845
|
+
export function serial(name: string, implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
846
|
+
export function serial(implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
847
|
+
export const failing: typeof test.failing.only;
|
|
848
|
+
export const cb: typeof test.cb.only;
|
|
849
|
+
}
|
|
850
|
+
export namespace test.only.serial {
|
|
851
|
+
export const failing: typeof test.failing.only.serial;
|
|
852
|
+
export const cb: typeof test.cb.only.serial;
|
|
853
|
+
}
|
|
854
|
+
export namespace test.beforeEach {
|
|
855
|
+
export function serial(name: string, implementation: ContextualTest): void;
|
|
856
|
+
export function serial(implementation: ContextualTest): void;
|
|
857
|
+
export function serial(name: string, implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
858
|
+
export function serial(implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
859
|
+
export function skip(name: string, implementation: ContextualTest): void;
|
|
860
|
+
export function skip(implementation: ContextualTest): void;
|
|
861
|
+
export function skip(name: string, implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
862
|
+
export function skip(implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
863
|
+
export function todo(name: string, implementation: ContextualTest): void;
|
|
864
|
+
export function todo(implementation: ContextualTest): void;
|
|
865
|
+
export function todo(name: string, implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
866
|
+
export function todo(implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
867
|
+
export function failing(name: string, implementation: ContextualTest): void;
|
|
868
|
+
export function failing(implementation: ContextualTest): void;
|
|
869
|
+
export function failing(name: string, implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
870
|
+
export function failing(implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
871
|
+
export function cb(name: string, implementation: ContextualCallbackTest): void;
|
|
872
|
+
export function cb(implementation: ContextualCallbackTest): void;
|
|
873
|
+
export function cb(name: string, implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
874
|
+
export function cb(implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
875
|
+
}
|
|
876
|
+
export namespace test.beforeEach.serial {
|
|
877
|
+
export function skip(name: string, implementation: ContextualTest): void;
|
|
878
|
+
export function skip(implementation: ContextualTest): void;
|
|
879
|
+
export function skip(name: string, implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
880
|
+
export function skip(implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
881
|
+
export function todo(name: string, implementation: ContextualTest): void;
|
|
882
|
+
export function todo(implementation: ContextualTest): void;
|
|
883
|
+
export function todo(name: string, implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
884
|
+
export function todo(implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
885
|
+
export const failing: typeof test.beforeEach.failing.serial;
|
|
886
|
+
export const cb: typeof test.beforeEach.cb.serial;
|
|
887
|
+
}
|
|
888
|
+
export namespace test.beforeEach.serial.skip {
|
|
889
|
+
export const failing: typeof test.beforeEach.failing.serial.skip;
|
|
890
|
+
export const cb: typeof test.beforeEach.cb.serial.skip;
|
|
891
|
+
}
|
|
892
|
+
export namespace test.beforeEach.serial.todo {
|
|
893
|
+
export const failing: typeof test.beforeEach.failing.serial.todo;
|
|
894
|
+
export const cb: typeof test.beforeEach.cb.serial.todo;
|
|
895
|
+
}
|
|
896
|
+
export namespace test.beforeEach.skip {
|
|
897
|
+
export const serial: typeof test.beforeEach.serial.skip;
|
|
898
|
+
export const failing: typeof test.beforeEach.failing.skip;
|
|
899
|
+
export const cb: typeof test.beforeEach.cb.skip;
|
|
900
|
+
}
|
|
901
|
+
export namespace test.beforeEach.todo {
|
|
902
|
+
export const serial: typeof test.beforeEach.serial.todo;
|
|
903
|
+
export const failing: typeof test.beforeEach.failing.todo;
|
|
904
|
+
export const cb: typeof test.beforeEach.cb.todo;
|
|
905
|
+
}
|
|
906
|
+
export namespace test.beforeEach.failing {
|
|
907
|
+
export function serial(name: string, implementation: ContextualTest): void;
|
|
908
|
+
export function serial(implementation: ContextualTest): void;
|
|
909
|
+
export function serial(name: string, implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
910
|
+
export function serial(implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
911
|
+
export function skip(name: string, implementation: ContextualTest): void;
|
|
912
|
+
export function skip(implementation: ContextualTest): void;
|
|
913
|
+
export function skip(name: string, implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
914
|
+
export function skip(implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
915
|
+
export function todo(name: string, implementation: ContextualTest): void;
|
|
916
|
+
export function todo(implementation: ContextualTest): void;
|
|
917
|
+
export function todo(name: string, implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
918
|
+
export function todo(implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
919
|
+
export const cb: typeof test.beforeEach.cb.failing;
|
|
920
|
+
}
|
|
921
|
+
export namespace test.beforeEach.failing.serial {
|
|
922
|
+
export function skip(name: string, implementation: ContextualTest): void;
|
|
923
|
+
export function skip(implementation: ContextualTest): void;
|
|
924
|
+
export function skip(name: string, implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
925
|
+
export function skip(implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
926
|
+
export function todo(name: string, implementation: ContextualTest): void;
|
|
927
|
+
export function todo(implementation: ContextualTest): void;
|
|
928
|
+
export function todo(name: string, implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
929
|
+
export function todo(implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
930
|
+
export const cb: typeof test.beforeEach.cb.failing.serial;
|
|
931
|
+
}
|
|
932
|
+
export namespace test.beforeEach.failing.serial.skip {
|
|
933
|
+
export const cb: typeof test.beforeEach.cb.failing.serial.skip;
|
|
934
|
+
}
|
|
935
|
+
export namespace test.beforeEach.failing.serial.todo {
|
|
936
|
+
export const cb: typeof test.beforeEach.cb.failing.serial.todo;
|
|
937
|
+
}
|
|
938
|
+
export namespace test.beforeEach.failing.skip {
|
|
939
|
+
export const serial: typeof test.beforeEach.failing.serial.skip;
|
|
940
|
+
export const cb: typeof test.beforeEach.cb.failing.skip;
|
|
941
|
+
}
|
|
942
|
+
export namespace test.beforeEach.failing.todo {
|
|
943
|
+
export const serial: typeof test.beforeEach.failing.serial.todo;
|
|
944
|
+
export const cb: typeof test.beforeEach.cb.failing.todo;
|
|
945
|
+
}
|
|
946
|
+
export namespace test.beforeEach.cb {
|
|
947
|
+
export function serial(name: string, implementation: ContextualCallbackTest): void;
|
|
948
|
+
export function serial(implementation: ContextualCallbackTest): void;
|
|
949
|
+
export function serial(name: string, implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
950
|
+
export function serial(implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
951
|
+
export function skip(name: string, implementation: ContextualCallbackTest): void;
|
|
952
|
+
export function skip(implementation: ContextualCallbackTest): void;
|
|
953
|
+
export function skip(name: string, implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
954
|
+
export function skip(implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
955
|
+
export function todo(name: string, implementation: ContextualCallbackTest): void;
|
|
956
|
+
export function todo(implementation: ContextualCallbackTest): void;
|
|
957
|
+
export function todo(name: string, implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
958
|
+
export function todo(implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
959
|
+
export function failing(name: string, implementation: ContextualCallbackTest): void;
|
|
960
|
+
export function failing(implementation: ContextualCallbackTest): void;
|
|
961
|
+
export function failing(name: string, implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
962
|
+
export function failing(implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
963
|
+
}
|
|
964
|
+
export namespace test.beforeEach.cb.serial {
|
|
965
|
+
export function skip(name: string, implementation: ContextualCallbackTest): void;
|
|
966
|
+
export function skip(implementation: ContextualCallbackTest): void;
|
|
967
|
+
export function skip(name: string, implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
968
|
+
export function skip(implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
969
|
+
export function todo(name: string, implementation: ContextualCallbackTest): void;
|
|
970
|
+
export function todo(implementation: ContextualCallbackTest): void;
|
|
971
|
+
export function todo(name: string, implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
972
|
+
export function todo(implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
973
|
+
export const failing: typeof test.beforeEach.cb.failing.serial;
|
|
974
|
+
}
|
|
975
|
+
export namespace test.beforeEach.cb.serial.skip {
|
|
976
|
+
export const failing: typeof test.beforeEach.cb.failing.serial.skip;
|
|
977
|
+
}
|
|
978
|
+
export namespace test.beforeEach.cb.serial.todo {
|
|
979
|
+
export const failing: typeof test.beforeEach.cb.failing.serial.todo;
|
|
980
|
+
}
|
|
981
|
+
export namespace test.beforeEach.cb.skip {
|
|
982
|
+
export const serial: typeof test.beforeEach.cb.serial.skip;
|
|
983
|
+
export const failing: typeof test.beforeEach.cb.failing.skip;
|
|
984
|
+
}
|
|
985
|
+
export namespace test.beforeEach.cb.todo {
|
|
986
|
+
export const serial: typeof test.beforeEach.cb.serial.todo;
|
|
987
|
+
export const failing: typeof test.beforeEach.cb.failing.todo;
|
|
988
|
+
}
|
|
989
|
+
export namespace test.beforeEach.cb.failing {
|
|
990
|
+
export function serial(name: string, implementation: ContextualCallbackTest): void;
|
|
991
|
+
export function serial(implementation: ContextualCallbackTest): void;
|
|
992
|
+
export function serial(name: string, implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
993
|
+
export function serial(implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
994
|
+
export function skip(name: string, implementation: ContextualCallbackTest): void;
|
|
995
|
+
export function skip(implementation: ContextualCallbackTest): void;
|
|
996
|
+
export function skip(name: string, implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
997
|
+
export function skip(implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
998
|
+
export function todo(name: string, implementation: ContextualCallbackTest): void;
|
|
999
|
+
export function todo(implementation: ContextualCallbackTest): void;
|
|
1000
|
+
export function todo(name: string, implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
1001
|
+
export function todo(implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
1002
|
+
}
|
|
1003
|
+
export namespace test.beforeEach.cb.failing.serial {
|
|
1004
|
+
export function skip(name: string, implementation: ContextualCallbackTest): void;
|
|
1005
|
+
export function skip(implementation: ContextualCallbackTest): void;
|
|
1006
|
+
export function skip(name: string, implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
1007
|
+
export function skip(implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
1008
|
+
export function todo(name: string, implementation: ContextualCallbackTest): void;
|
|
1009
|
+
export function todo(implementation: ContextualCallbackTest): void;
|
|
1010
|
+
export function todo(name: string, implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
1011
|
+
export function todo(implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
1012
|
+
}
|
|
1013
|
+
export namespace test.beforeEach.cb.failing.skip {
|
|
1014
|
+
export const serial: typeof test.beforeEach.cb.failing.serial.skip;
|
|
1015
|
+
}
|
|
1016
|
+
export namespace test.beforeEach.cb.failing.todo {
|
|
1017
|
+
export const serial: typeof test.beforeEach.cb.failing.serial.todo;
|
|
1018
|
+
}
|
|
1019
|
+
export namespace test.afterEach {
|
|
1020
|
+
export function serial(name: string, implementation: ContextualTest): void;
|
|
1021
|
+
export function serial(implementation: ContextualTest): void;
|
|
1022
|
+
export function serial(name: string, implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
1023
|
+
export function serial(implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
1024
|
+
export function skip(name: string, implementation: ContextualTest): void;
|
|
1025
|
+
export function skip(implementation: ContextualTest): void;
|
|
1026
|
+
export function skip(name: string, implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
1027
|
+
export function skip(implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
1028
|
+
export function todo(name: string, implementation: ContextualTest): void;
|
|
1029
|
+
export function todo(implementation: ContextualTest): void;
|
|
1030
|
+
export function todo(name: string, implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
1031
|
+
export function todo(implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
1032
|
+
export function failing(name: string, implementation: ContextualTest): void;
|
|
1033
|
+
export function failing(implementation: ContextualTest): void;
|
|
1034
|
+
export function failing(name: string, implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
1035
|
+
export function failing(implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
1036
|
+
export function cb(name: string, implementation: ContextualCallbackTest): void;
|
|
1037
|
+
export function cb(implementation: ContextualCallbackTest): void;
|
|
1038
|
+
export function cb(name: string, implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
1039
|
+
export function cb(implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
1040
|
+
export function always(name: string, implementation: ContextualTest): void;
|
|
1041
|
+
export function always(implementation: ContextualTest): void;
|
|
1042
|
+
export function always(name: string, implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
1043
|
+
export function always(implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
1044
|
+
}
|
|
1045
|
+
export namespace test.afterEach.serial {
|
|
1046
|
+
export function skip(name: string, implementation: ContextualTest): void;
|
|
1047
|
+
export function skip(implementation: ContextualTest): void;
|
|
1048
|
+
export function skip(name: string, implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
1049
|
+
export function skip(implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
1050
|
+
export function todo(name: string, implementation: ContextualTest): void;
|
|
1051
|
+
export function todo(implementation: ContextualTest): void;
|
|
1052
|
+
export function todo(name: string, implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
1053
|
+
export function todo(implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
1054
|
+
export const failing: typeof test.afterEach.failing.serial;
|
|
1055
|
+
export const cb: typeof test.afterEach.cb.serial;
|
|
1056
|
+
export const always: typeof test.afterEach.always.serial;
|
|
1057
|
+
}
|
|
1058
|
+
export namespace test.afterEach.serial.skip {
|
|
1059
|
+
export const failing: typeof test.afterEach.failing.serial.skip;
|
|
1060
|
+
export const cb: typeof test.afterEach.cb.serial.skip;
|
|
1061
|
+
export const always: typeof test.afterEach.always.serial.skip;
|
|
1062
|
+
}
|
|
1063
|
+
export namespace test.afterEach.serial.todo {
|
|
1064
|
+
export const failing: typeof test.afterEach.failing.serial.todo;
|
|
1065
|
+
export const cb: typeof test.afterEach.cb.serial.todo;
|
|
1066
|
+
export const always: typeof test.afterEach.always.serial.todo;
|
|
1067
|
+
}
|
|
1068
|
+
export namespace test.afterEach.skip {
|
|
1069
|
+
export const serial: typeof test.afterEach.serial.skip;
|
|
1070
|
+
export const failing: typeof test.afterEach.failing.skip;
|
|
1071
|
+
export const cb: typeof test.afterEach.cb.skip;
|
|
1072
|
+
export const always: typeof test.afterEach.always.skip;
|
|
1073
|
+
}
|
|
1074
|
+
export namespace test.afterEach.todo {
|
|
1075
|
+
export const serial: typeof test.afterEach.serial.todo;
|
|
1076
|
+
export const failing: typeof test.afterEach.failing.todo;
|
|
1077
|
+
export const cb: typeof test.afterEach.cb.todo;
|
|
1078
|
+
export const always: typeof test.afterEach.always.todo;
|
|
1079
|
+
}
|
|
1080
|
+
export namespace test.afterEach.failing {
|
|
1081
|
+
export function serial(name: string, implementation: ContextualTest): void;
|
|
1082
|
+
export function serial(implementation: ContextualTest): void;
|
|
1083
|
+
export function serial(name: string, implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
1084
|
+
export function serial(implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
1085
|
+
export function skip(name: string, implementation: ContextualTest): void;
|
|
1086
|
+
export function skip(implementation: ContextualTest): void;
|
|
1087
|
+
export function skip(name: string, implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
1088
|
+
export function skip(implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
1089
|
+
export function todo(name: string, implementation: ContextualTest): void;
|
|
1090
|
+
export function todo(implementation: ContextualTest): void;
|
|
1091
|
+
export function todo(name: string, implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
1092
|
+
export function todo(implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
1093
|
+
export const cb: typeof test.afterEach.cb.failing;
|
|
1094
|
+
export const always: typeof test.afterEach.always.failing;
|
|
1095
|
+
}
|
|
1096
|
+
export namespace test.afterEach.failing.serial {
|
|
1097
|
+
export function skip(name: string, implementation: ContextualTest): void;
|
|
1098
|
+
export function skip(implementation: ContextualTest): void;
|
|
1099
|
+
export function skip(name: string, implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
1100
|
+
export function skip(implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
1101
|
+
export function todo(name: string, implementation: ContextualTest): void;
|
|
1102
|
+
export function todo(implementation: ContextualTest): void;
|
|
1103
|
+
export function todo(name: string, implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
1104
|
+
export function todo(implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
1105
|
+
export const cb: typeof test.afterEach.cb.failing.serial;
|
|
1106
|
+
export const always: typeof test.afterEach.always.failing.serial;
|
|
1107
|
+
}
|
|
1108
|
+
export namespace test.afterEach.failing.serial.skip {
|
|
1109
|
+
export const cb: typeof test.afterEach.cb.failing.serial.skip;
|
|
1110
|
+
export const always: typeof test.afterEach.always.failing.serial.skip;
|
|
1111
|
+
}
|
|
1112
|
+
export namespace test.afterEach.failing.serial.todo {
|
|
1113
|
+
export const cb: typeof test.afterEach.cb.failing.serial.todo;
|
|
1114
|
+
export const always: typeof test.afterEach.always.failing.serial.todo;
|
|
1115
|
+
}
|
|
1116
|
+
export namespace test.afterEach.failing.skip {
|
|
1117
|
+
export const serial: typeof test.afterEach.failing.serial.skip;
|
|
1118
|
+
export const cb: typeof test.afterEach.cb.failing.skip;
|
|
1119
|
+
export const always: typeof test.afterEach.always.failing.skip;
|
|
1120
|
+
}
|
|
1121
|
+
export namespace test.afterEach.failing.todo {
|
|
1122
|
+
export const serial: typeof test.afterEach.failing.serial.todo;
|
|
1123
|
+
export const cb: typeof test.afterEach.cb.failing.todo;
|
|
1124
|
+
export const always: typeof test.afterEach.always.failing.todo;
|
|
1125
|
+
}
|
|
1126
|
+
export namespace test.afterEach.cb {
|
|
1127
|
+
export function serial(name: string, implementation: ContextualCallbackTest): void;
|
|
1128
|
+
export function serial(implementation: ContextualCallbackTest): void;
|
|
1129
|
+
export function serial(name: string, implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
1130
|
+
export function serial(implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
1131
|
+
export function skip(name: string, implementation: ContextualCallbackTest): void;
|
|
1132
|
+
export function skip(implementation: ContextualCallbackTest): void;
|
|
1133
|
+
export function skip(name: string, implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
1134
|
+
export function skip(implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
1135
|
+
export function todo(name: string, implementation: ContextualCallbackTest): void;
|
|
1136
|
+
export function todo(implementation: ContextualCallbackTest): void;
|
|
1137
|
+
export function todo(name: string, implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
1138
|
+
export function todo(implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
1139
|
+
export function failing(name: string, implementation: ContextualCallbackTest): void;
|
|
1140
|
+
export function failing(implementation: ContextualCallbackTest): void;
|
|
1141
|
+
export function failing(name: string, implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
1142
|
+
export function failing(implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
1143
|
+
export const always: typeof test.afterEach.always.cb;
|
|
1144
|
+
}
|
|
1145
|
+
export namespace test.afterEach.cb.serial {
|
|
1146
|
+
export function skip(name: string, implementation: ContextualCallbackTest): void;
|
|
1147
|
+
export function skip(implementation: ContextualCallbackTest): void;
|
|
1148
|
+
export function skip(name: string, implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
1149
|
+
export function skip(implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
1150
|
+
export function todo(name: string, implementation: ContextualCallbackTest): void;
|
|
1151
|
+
export function todo(implementation: ContextualCallbackTest): void;
|
|
1152
|
+
export function todo(name: string, implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
1153
|
+
export function todo(implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
1154
|
+
export const failing: typeof test.afterEach.cb.failing.serial;
|
|
1155
|
+
export const always: typeof test.afterEach.always.cb.serial;
|
|
1156
|
+
}
|
|
1157
|
+
export namespace test.afterEach.cb.serial.skip {
|
|
1158
|
+
export const failing: typeof test.afterEach.cb.failing.serial.skip;
|
|
1159
|
+
export const always: typeof test.afterEach.always.cb.serial.skip;
|
|
1160
|
+
}
|
|
1161
|
+
export namespace test.afterEach.cb.serial.todo {
|
|
1162
|
+
export const failing: typeof test.afterEach.cb.failing.serial.todo;
|
|
1163
|
+
export const always: typeof test.afterEach.always.cb.serial.todo;
|
|
1164
|
+
}
|
|
1165
|
+
export namespace test.afterEach.cb.skip {
|
|
1166
|
+
export const serial: typeof test.afterEach.cb.serial.skip;
|
|
1167
|
+
export const failing: typeof test.afterEach.cb.failing.skip;
|
|
1168
|
+
export const always: typeof test.afterEach.always.cb.skip;
|
|
1169
|
+
}
|
|
1170
|
+
export namespace test.afterEach.cb.todo {
|
|
1171
|
+
export const serial: typeof test.afterEach.cb.serial.todo;
|
|
1172
|
+
export const failing: typeof test.afterEach.cb.failing.todo;
|
|
1173
|
+
export const always: typeof test.afterEach.always.cb.todo;
|
|
1174
|
+
}
|
|
1175
|
+
export namespace test.afterEach.cb.failing {
|
|
1176
|
+
export function serial(name: string, implementation: ContextualCallbackTest): void;
|
|
1177
|
+
export function serial(implementation: ContextualCallbackTest): void;
|
|
1178
|
+
export function serial(name: string, implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
1179
|
+
export function serial(implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
1180
|
+
export function skip(name: string, implementation: ContextualCallbackTest): void;
|
|
1181
|
+
export function skip(implementation: ContextualCallbackTest): void;
|
|
1182
|
+
export function skip(name: string, implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
1183
|
+
export function skip(implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
1184
|
+
export function todo(name: string, implementation: ContextualCallbackTest): void;
|
|
1185
|
+
export function todo(implementation: ContextualCallbackTest): void;
|
|
1186
|
+
export function todo(name: string, implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
1187
|
+
export function todo(implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
1188
|
+
export const always: typeof test.afterEach.always.cb.failing;
|
|
1189
|
+
}
|
|
1190
|
+
export namespace test.afterEach.cb.failing.serial {
|
|
1191
|
+
export function skip(name: string, implementation: ContextualCallbackTest): void;
|
|
1192
|
+
export function skip(implementation: ContextualCallbackTest): void;
|
|
1193
|
+
export function skip(name: string, implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
1194
|
+
export function skip(implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
1195
|
+
export function todo(name: string, implementation: ContextualCallbackTest): void;
|
|
1196
|
+
export function todo(implementation: ContextualCallbackTest): void;
|
|
1197
|
+
export function todo(name: string, implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
1198
|
+
export function todo(implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
1199
|
+
export const always: typeof test.afterEach.always.cb.failing.serial;
|
|
1200
|
+
}
|
|
1201
|
+
export namespace test.afterEach.cb.failing.serial.skip {
|
|
1202
|
+
export const always: typeof test.afterEach.always.cb.failing.serial.skip;
|
|
1203
|
+
}
|
|
1204
|
+
export namespace test.afterEach.cb.failing.serial.todo {
|
|
1205
|
+
export const always: typeof test.afterEach.always.cb.failing.serial.todo;
|
|
1206
|
+
}
|
|
1207
|
+
export namespace test.afterEach.cb.failing.skip {
|
|
1208
|
+
export const serial: typeof test.afterEach.cb.failing.serial.skip;
|
|
1209
|
+
export const always: typeof test.afterEach.always.cb.failing.skip;
|
|
1210
|
+
}
|
|
1211
|
+
export namespace test.afterEach.cb.failing.todo {
|
|
1212
|
+
export const serial: typeof test.afterEach.cb.failing.serial.todo;
|
|
1213
|
+
export const always: typeof test.afterEach.always.cb.failing.todo;
|
|
1214
|
+
}
|
|
1215
|
+
export namespace test.afterEach.always {
|
|
1216
|
+
export function serial(name: string, implementation: ContextualTest): void;
|
|
1217
|
+
export function serial(implementation: ContextualTest): void;
|
|
1218
|
+
export function serial(name: string, implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
1219
|
+
export function serial(implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
1220
|
+
export function skip(name: string, implementation: ContextualTest): void;
|
|
1221
|
+
export function skip(implementation: ContextualTest): void;
|
|
1222
|
+
export function skip(name: string, implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
1223
|
+
export function skip(implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
1224
|
+
export function todo(name: string, implementation: ContextualTest): void;
|
|
1225
|
+
export function todo(implementation: ContextualTest): void;
|
|
1226
|
+
export function todo(name: string, implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
1227
|
+
export function todo(implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
1228
|
+
export function failing(name: string, implementation: ContextualTest): void;
|
|
1229
|
+
export function failing(implementation: ContextualTest): void;
|
|
1230
|
+
export function failing(name: string, implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
1231
|
+
export function failing(implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
1232
|
+
export function cb(name: string, implementation: ContextualCallbackTest): void;
|
|
1233
|
+
export function cb(implementation: ContextualCallbackTest): void;
|
|
1234
|
+
export function cb(name: string, implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
1235
|
+
export function cb(implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
1236
|
+
}
|
|
1237
|
+
export namespace test.afterEach.always.serial {
|
|
1238
|
+
export function skip(name: string, implementation: ContextualTest): void;
|
|
1239
|
+
export function skip(implementation: ContextualTest): void;
|
|
1240
|
+
export function skip(name: string, implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
1241
|
+
export function skip(implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
1242
|
+
export function todo(name: string, implementation: ContextualTest): void;
|
|
1243
|
+
export function todo(implementation: ContextualTest): void;
|
|
1244
|
+
export function todo(name: string, implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
1245
|
+
export function todo(implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
1246
|
+
export const failing: typeof test.afterEach.always.failing.serial;
|
|
1247
|
+
export const cb: typeof test.afterEach.always.cb.serial;
|
|
1248
|
+
}
|
|
1249
|
+
export namespace test.afterEach.always.serial.skip {
|
|
1250
|
+
export const failing: typeof test.afterEach.always.failing.serial.skip;
|
|
1251
|
+
export const cb: typeof test.afterEach.always.cb.serial.skip;
|
|
1252
|
+
}
|
|
1253
|
+
export namespace test.afterEach.always.serial.todo {
|
|
1254
|
+
export const failing: typeof test.afterEach.always.failing.serial.todo;
|
|
1255
|
+
export const cb: typeof test.afterEach.always.cb.serial.todo;
|
|
1256
|
+
}
|
|
1257
|
+
export namespace test.afterEach.always.skip {
|
|
1258
|
+
export const serial: typeof test.afterEach.always.serial.skip;
|
|
1259
|
+
export const failing: typeof test.afterEach.always.failing.skip;
|
|
1260
|
+
export const cb: typeof test.afterEach.always.cb.skip;
|
|
1261
|
+
}
|
|
1262
|
+
export namespace test.afterEach.always.todo {
|
|
1263
|
+
export const serial: typeof test.afterEach.always.serial.todo;
|
|
1264
|
+
export const failing: typeof test.afterEach.always.failing.todo;
|
|
1265
|
+
export const cb: typeof test.afterEach.always.cb.todo;
|
|
1266
|
+
}
|
|
1267
|
+
export namespace test.afterEach.always.failing {
|
|
1268
|
+
export function serial(name: string, implementation: ContextualTest): void;
|
|
1269
|
+
export function serial(implementation: ContextualTest): void;
|
|
1270
|
+
export function serial(name: string, implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
1271
|
+
export function serial(implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
1272
|
+
export function skip(name: string, implementation: ContextualTest): void;
|
|
1273
|
+
export function skip(implementation: ContextualTest): void;
|
|
1274
|
+
export function skip(name: string, implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
1275
|
+
export function skip(implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
1276
|
+
export function todo(name: string, implementation: ContextualTest): void;
|
|
1277
|
+
export function todo(implementation: ContextualTest): void;
|
|
1278
|
+
export function todo(name: string, implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
1279
|
+
export function todo(implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
1280
|
+
export const cb: typeof test.afterEach.always.cb.failing;
|
|
1281
|
+
}
|
|
1282
|
+
export namespace test.afterEach.always.failing.serial {
|
|
1283
|
+
export function skip(name: string, implementation: ContextualTest): void;
|
|
1284
|
+
export function skip(implementation: ContextualTest): void;
|
|
1285
|
+
export function skip(name: string, implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
1286
|
+
export function skip(implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
1287
|
+
export function todo(name: string, implementation: ContextualTest): void;
|
|
1288
|
+
export function todo(implementation: ContextualTest): void;
|
|
1289
|
+
export function todo(name: string, implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
1290
|
+
export function todo(implementation: Macros<ContextualTestContext>, ...args: any[]): void;
|
|
1291
|
+
export const cb: typeof test.afterEach.always.cb.failing.serial;
|
|
1292
|
+
}
|
|
1293
|
+
export namespace test.afterEach.always.failing.serial.skip {
|
|
1294
|
+
export const cb: typeof test.afterEach.always.cb.failing.serial.skip;
|
|
1295
|
+
}
|
|
1296
|
+
export namespace test.afterEach.always.failing.serial.todo {
|
|
1297
|
+
export const cb: typeof test.afterEach.always.cb.failing.serial.todo;
|
|
1298
|
+
}
|
|
1299
|
+
export namespace test.afterEach.always.failing.skip {
|
|
1300
|
+
export const serial: typeof test.afterEach.always.failing.serial.skip;
|
|
1301
|
+
export const cb: typeof test.afterEach.always.cb.failing.skip;
|
|
1302
|
+
}
|
|
1303
|
+
export namespace test.afterEach.always.failing.todo {
|
|
1304
|
+
export const serial: typeof test.afterEach.always.failing.serial.todo;
|
|
1305
|
+
export const cb: typeof test.afterEach.always.cb.failing.todo;
|
|
1306
|
+
}
|
|
1307
|
+
export namespace test.afterEach.always.cb {
|
|
1308
|
+
export function serial(name: string, implementation: ContextualCallbackTest): void;
|
|
1309
|
+
export function serial(implementation: ContextualCallbackTest): void;
|
|
1310
|
+
export function serial(name: string, implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
1311
|
+
export function serial(implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
1312
|
+
export function skip(name: string, implementation: ContextualCallbackTest): void;
|
|
1313
|
+
export function skip(implementation: ContextualCallbackTest): void;
|
|
1314
|
+
export function skip(name: string, implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
1315
|
+
export function skip(implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
1316
|
+
export function todo(name: string, implementation: ContextualCallbackTest): void;
|
|
1317
|
+
export function todo(implementation: ContextualCallbackTest): void;
|
|
1318
|
+
export function todo(name: string, implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
1319
|
+
export function todo(implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
1320
|
+
export function failing(name: string, implementation: ContextualCallbackTest): void;
|
|
1321
|
+
export function failing(implementation: ContextualCallbackTest): void;
|
|
1322
|
+
export function failing(name: string, implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
1323
|
+
export function failing(implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
1324
|
+
}
|
|
1325
|
+
export namespace test.afterEach.always.cb.serial {
|
|
1326
|
+
export function skip(name: string, implementation: ContextualCallbackTest): void;
|
|
1327
|
+
export function skip(implementation: ContextualCallbackTest): void;
|
|
1328
|
+
export function skip(name: string, implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
1329
|
+
export function skip(implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
1330
|
+
export function todo(name: string, implementation: ContextualCallbackTest): void;
|
|
1331
|
+
export function todo(implementation: ContextualCallbackTest): void;
|
|
1332
|
+
export function todo(name: string, implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
1333
|
+
export function todo(implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
1334
|
+
export const failing: typeof test.afterEach.always.cb.failing.serial;
|
|
1335
|
+
}
|
|
1336
|
+
export namespace test.afterEach.always.cb.serial.skip {
|
|
1337
|
+
export const failing: typeof test.afterEach.always.cb.failing.serial.skip;
|
|
1338
|
+
}
|
|
1339
|
+
export namespace test.afterEach.always.cb.serial.todo {
|
|
1340
|
+
export const failing: typeof test.afterEach.always.cb.failing.serial.todo;
|
|
1341
|
+
}
|
|
1342
|
+
export namespace test.afterEach.always.cb.skip {
|
|
1343
|
+
export const serial: typeof test.afterEach.always.cb.serial.skip;
|
|
1344
|
+
export const failing: typeof test.afterEach.always.cb.failing.skip;
|
|
1345
|
+
}
|
|
1346
|
+
export namespace test.afterEach.always.cb.todo {
|
|
1347
|
+
export const serial: typeof test.afterEach.always.cb.serial.todo;
|
|
1348
|
+
export const failing: typeof test.afterEach.always.cb.failing.todo;
|
|
1349
|
+
}
|
|
1350
|
+
export namespace test.afterEach.always.cb.failing {
|
|
1351
|
+
export function serial(name: string, implementation: ContextualCallbackTest): void;
|
|
1352
|
+
export function serial(implementation: ContextualCallbackTest): void;
|
|
1353
|
+
export function serial(name: string, implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
1354
|
+
export function serial(implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
1355
|
+
export function skip(name: string, implementation: ContextualCallbackTest): void;
|
|
1356
|
+
export function skip(implementation: ContextualCallbackTest): void;
|
|
1357
|
+
export function skip(name: string, implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
1358
|
+
export function skip(implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
1359
|
+
export function todo(name: string, implementation: ContextualCallbackTest): void;
|
|
1360
|
+
export function todo(implementation: ContextualCallbackTest): void;
|
|
1361
|
+
export function todo(name: string, implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
1362
|
+
export function todo(implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
1363
|
+
}
|
|
1364
|
+
export namespace test.afterEach.always.cb.failing.serial {
|
|
1365
|
+
export function skip(name: string, implementation: ContextualCallbackTest): void;
|
|
1366
|
+
export function skip(implementation: ContextualCallbackTest): void;
|
|
1367
|
+
export function skip(name: string, implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
1368
|
+
export function skip(implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
1369
|
+
export function todo(name: string, implementation: ContextualCallbackTest): void;
|
|
1370
|
+
export function todo(implementation: ContextualCallbackTest): void;
|
|
1371
|
+
export function todo(name: string, implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
1372
|
+
export function todo(implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
1373
|
+
}
|
|
1374
|
+
export namespace test.afterEach.always.cb.failing.skip {
|
|
1375
|
+
export const serial: typeof test.afterEach.always.cb.failing.serial.skip;
|
|
1376
|
+
}
|
|
1377
|
+
export namespace test.afterEach.always.cb.failing.todo {
|
|
1378
|
+
export const serial: typeof test.afterEach.always.cb.failing.serial.todo;
|
|
1379
|
+
}
|
|
1380
|
+
export namespace test.cb {
|
|
1381
|
+
export function serial(name: string, implementation: ContextualCallbackTest): void;
|
|
1382
|
+
export function serial(implementation: ContextualCallbackTest): void;
|
|
1383
|
+
export function serial(name: string, implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
1384
|
+
export function serial(implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
1385
|
+
export const before: typeof test.before.cb;
|
|
1386
|
+
export const after: typeof test.after.cb;
|
|
1387
|
+
export function skip(name: string, implementation: ContextualCallbackTest): void;
|
|
1388
|
+
export function skip(implementation: ContextualCallbackTest): void;
|
|
1389
|
+
export function skip(name: string, implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
1390
|
+
export function skip(implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
1391
|
+
export function todo(name: string, implementation: ContextualCallbackTest): void;
|
|
1392
|
+
export function todo(implementation: ContextualCallbackTest): void;
|
|
1393
|
+
export function todo(name: string, implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
1394
|
+
export function todo(implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
1395
|
+
export function failing(name: string, implementation: ContextualCallbackTest): void;
|
|
1396
|
+
export function failing(implementation: ContextualCallbackTest): void;
|
|
1397
|
+
export function failing(name: string, implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
1398
|
+
export function failing(implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
1399
|
+
export function only(name: string, implementation: ContextualCallbackTest): void;
|
|
1400
|
+
export function only(implementation: ContextualCallbackTest): void;
|
|
1401
|
+
export function only(name: string, implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
1402
|
+
export function only(implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
1403
|
+
export const beforeEach: typeof test.beforeEach.cb;
|
|
1404
|
+
export const afterEach: typeof test.afterEach.cb;
|
|
1405
|
+
export const always: typeof test.always.cb;
|
|
1406
|
+
}
|
|
1407
|
+
export namespace test.cb.serial {
|
|
1408
|
+
export const before: typeof test.before.cb.serial;
|
|
1409
|
+
export const after: typeof test.after.cb.serial;
|
|
1410
|
+
export function skip(name: string, implementation: ContextualCallbackTest): void;
|
|
1411
|
+
export function skip(implementation: ContextualCallbackTest): void;
|
|
1412
|
+
export function skip(name: string, implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
1413
|
+
export function skip(implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
1414
|
+
export function todo(name: string, implementation: ContextualCallbackTest): void;
|
|
1415
|
+
export function todo(implementation: ContextualCallbackTest): void;
|
|
1416
|
+
export function todo(name: string, implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
1417
|
+
export function todo(implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
1418
|
+
export const failing: typeof test.cb.failing.serial;
|
|
1419
|
+
export const only: typeof test.cb.only.serial;
|
|
1420
|
+
export const beforeEach: typeof test.beforeEach.cb.serial;
|
|
1421
|
+
export const afterEach: typeof test.afterEach.cb.serial;
|
|
1422
|
+
export const always: typeof test.always.cb.serial;
|
|
1423
|
+
}
|
|
1424
|
+
export namespace test.cb.serial.skip {
|
|
1425
|
+
export const before: typeof test.before.cb.serial.skip;
|
|
1426
|
+
export const after: typeof test.after.cb.serial.skip;
|
|
1427
|
+
export const failing: typeof test.cb.failing.serial.skip;
|
|
1428
|
+
export const beforeEach: typeof test.beforeEach.cb.serial.skip;
|
|
1429
|
+
export const afterEach: typeof test.afterEach.cb.serial.skip;
|
|
1430
|
+
export const always: typeof test.always.cb.serial.skip;
|
|
1431
|
+
}
|
|
1432
|
+
export namespace test.cb.serial.todo {
|
|
1433
|
+
export const before: typeof test.before.cb.serial.todo;
|
|
1434
|
+
export const after: typeof test.after.cb.serial.todo;
|
|
1435
|
+
export const failing: typeof test.cb.failing.serial.todo;
|
|
1436
|
+
export const beforeEach: typeof test.beforeEach.cb.serial.todo;
|
|
1437
|
+
export const afterEach: typeof test.afterEach.cb.serial.todo;
|
|
1438
|
+
export const always: typeof test.always.cb.serial.todo;
|
|
1439
|
+
}
|
|
1440
|
+
export namespace test.cb.skip {
|
|
1441
|
+
export const serial: typeof test.cb.serial.skip;
|
|
1442
|
+
export const before: typeof test.before.cb.skip;
|
|
1443
|
+
export const after: typeof test.after.cb.skip;
|
|
1444
|
+
export const failing: typeof test.cb.failing.skip;
|
|
1445
|
+
export const beforeEach: typeof test.beforeEach.cb.skip;
|
|
1446
|
+
export const afterEach: typeof test.afterEach.cb.skip;
|
|
1447
|
+
export const always: typeof test.always.cb.skip;
|
|
1448
|
+
}
|
|
1449
|
+
export namespace test.cb.todo {
|
|
1450
|
+
export const serial: typeof test.cb.serial.todo;
|
|
1451
|
+
export const before: typeof test.before.cb.todo;
|
|
1452
|
+
export const after: typeof test.after.cb.todo;
|
|
1453
|
+
export const failing: typeof test.cb.failing.todo;
|
|
1454
|
+
export const beforeEach: typeof test.beforeEach.cb.todo;
|
|
1455
|
+
export const afterEach: typeof test.afterEach.cb.todo;
|
|
1456
|
+
export const always: typeof test.always.cb.todo;
|
|
1457
|
+
}
|
|
1458
|
+
export namespace test.cb.failing {
|
|
1459
|
+
export function serial(name: string, implementation: ContextualCallbackTest): void;
|
|
1460
|
+
export function serial(implementation: ContextualCallbackTest): void;
|
|
1461
|
+
export function serial(name: string, implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
1462
|
+
export function serial(implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
1463
|
+
export const before: typeof test.before.cb.failing;
|
|
1464
|
+
export const after: typeof test.after.cb.failing;
|
|
1465
|
+
export function skip(name: string, implementation: ContextualCallbackTest): void;
|
|
1466
|
+
export function skip(implementation: ContextualCallbackTest): void;
|
|
1467
|
+
export function skip(name: string, implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
1468
|
+
export function skip(implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
1469
|
+
export function todo(name: string, implementation: ContextualCallbackTest): void;
|
|
1470
|
+
export function todo(implementation: ContextualCallbackTest): void;
|
|
1471
|
+
export function todo(name: string, implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
1472
|
+
export function todo(implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
1473
|
+
export function only(name: string, implementation: ContextualCallbackTest): void;
|
|
1474
|
+
export function only(implementation: ContextualCallbackTest): void;
|
|
1475
|
+
export function only(name: string, implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
1476
|
+
export function only(implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
1477
|
+
export const beforeEach: typeof test.beforeEach.cb.failing;
|
|
1478
|
+
export const afterEach: typeof test.afterEach.cb.failing;
|
|
1479
|
+
export const always: typeof test.always.cb.failing;
|
|
1480
|
+
}
|
|
1481
|
+
export namespace test.cb.failing.serial {
|
|
1482
|
+
export const before: typeof test.before.cb.failing.serial;
|
|
1483
|
+
export const after: typeof test.after.cb.failing.serial;
|
|
1484
|
+
export function skip(name: string, implementation: ContextualCallbackTest): void;
|
|
1485
|
+
export function skip(implementation: ContextualCallbackTest): void;
|
|
1486
|
+
export function skip(name: string, implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
1487
|
+
export function skip(implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
1488
|
+
export function todo(name: string, implementation: ContextualCallbackTest): void;
|
|
1489
|
+
export function todo(implementation: ContextualCallbackTest): void;
|
|
1490
|
+
export function todo(name: string, implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
1491
|
+
export function todo(implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
1492
|
+
export const only: typeof test.cb.failing.only.serial;
|
|
1493
|
+
export const beforeEach: typeof test.beforeEach.cb.failing.serial;
|
|
1494
|
+
export const afterEach: typeof test.afterEach.cb.failing.serial;
|
|
1495
|
+
export const always: typeof test.always.cb.failing.serial;
|
|
1496
|
+
}
|
|
1497
|
+
export namespace test.cb.failing.serial.skip {
|
|
1498
|
+
export const before: typeof test.before.cb.failing.serial.skip;
|
|
1499
|
+
export const after: typeof test.after.cb.failing.serial.skip;
|
|
1500
|
+
export const beforeEach: typeof test.beforeEach.cb.failing.serial.skip;
|
|
1501
|
+
export const afterEach: typeof test.afterEach.cb.failing.serial.skip;
|
|
1502
|
+
export const always: typeof test.always.cb.failing.serial.skip;
|
|
1503
|
+
}
|
|
1504
|
+
export namespace test.cb.failing.serial.todo {
|
|
1505
|
+
export const before: typeof test.before.cb.failing.serial.todo;
|
|
1506
|
+
export const after: typeof test.after.cb.failing.serial.todo;
|
|
1507
|
+
export const beforeEach: typeof test.beforeEach.cb.failing.serial.todo;
|
|
1508
|
+
export const afterEach: typeof test.afterEach.cb.failing.serial.todo;
|
|
1509
|
+
export const always: typeof test.always.cb.failing.serial.todo;
|
|
1510
|
+
}
|
|
1511
|
+
export namespace test.cb.failing.skip {
|
|
1512
|
+
export const serial: typeof test.cb.failing.serial.skip;
|
|
1513
|
+
export const before: typeof test.before.cb.failing.skip;
|
|
1514
|
+
export const after: typeof test.after.cb.failing.skip;
|
|
1515
|
+
export const beforeEach: typeof test.beforeEach.cb.failing.skip;
|
|
1516
|
+
export const afterEach: typeof test.afterEach.cb.failing.skip;
|
|
1517
|
+
export const always: typeof test.always.cb.failing.skip;
|
|
1518
|
+
}
|
|
1519
|
+
export namespace test.cb.failing.todo {
|
|
1520
|
+
export const serial: typeof test.cb.failing.serial.todo;
|
|
1521
|
+
export const before: typeof test.before.cb.failing.todo;
|
|
1522
|
+
export const after: typeof test.after.cb.failing.todo;
|
|
1523
|
+
export const beforeEach: typeof test.beforeEach.cb.failing.todo;
|
|
1524
|
+
export const afterEach: typeof test.afterEach.cb.failing.todo;
|
|
1525
|
+
export const always: typeof test.always.cb.failing.todo;
|
|
1526
|
+
}
|
|
1527
|
+
export namespace test.cb.failing.only {
|
|
1528
|
+
export function serial(name: string, implementation: ContextualCallbackTest): void;
|
|
1529
|
+
export function serial(implementation: ContextualCallbackTest): void;
|
|
1530
|
+
export function serial(name: string, implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
1531
|
+
export function serial(implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
1532
|
+
}
|
|
1533
|
+
export namespace test.cb.only {
|
|
1534
|
+
export function serial(name: string, implementation: ContextualCallbackTest): void;
|
|
1535
|
+
export function serial(implementation: ContextualCallbackTest): void;
|
|
1536
|
+
export function serial(name: string, implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
1537
|
+
export function serial(implementation: Macros<ContextualCallbackTestContext>, ...args: any[]): void;
|
|
1538
|
+
export const failing: typeof test.cb.failing.only;
|
|
1539
|
+
}
|
|
1540
|
+
export namespace test.cb.only.serial {
|
|
1541
|
+
export const failing: typeof test.cb.failing.only.serial;
|
|
1542
|
+
}
|
|
1543
|
+
export namespace test.always {
|
|
1544
|
+
export const after: typeof test.after.always;
|
|
1545
|
+
export const afterEach: typeof test.afterEach.always;
|
|
1546
|
+
}
|
|
1547
|
+
export namespace test.always.serial {
|
|
1548
|
+
export const after: typeof test.after.always.serial;
|
|
1549
|
+
export const failing: typeof test.always.failing.serial;
|
|
1550
|
+
export const afterEach: typeof test.afterEach.always.serial;
|
|
1551
|
+
export const cb: typeof test.always.cb.serial;
|
|
1552
|
+
}
|
|
1553
|
+
export namespace test.always.serial.skip {
|
|
1554
|
+
export const after: typeof test.after.always.serial.skip;
|
|
1555
|
+
export const failing: typeof test.always.failing.serial.skip;
|
|
1556
|
+
export const afterEach: typeof test.afterEach.always.serial.skip;
|
|
1557
|
+
export const cb: typeof test.always.cb.serial.skip;
|
|
1558
|
+
}
|
|
1559
|
+
export namespace test.always.serial.todo {
|
|
1560
|
+
export const after: typeof test.after.always.serial.todo;
|
|
1561
|
+
export const failing: typeof test.always.failing.serial.todo;
|
|
1562
|
+
export const afterEach: typeof test.afterEach.always.serial.todo;
|
|
1563
|
+
export const cb: typeof test.always.cb.serial.todo;
|
|
1564
|
+
}
|
|
1565
|
+
export namespace test.always.skip {
|
|
1566
|
+
export const serial: typeof test.always.serial.skip;
|
|
1567
|
+
export const after: typeof test.after.always.skip;
|
|
1568
|
+
export const failing: typeof test.always.failing.skip;
|
|
1569
|
+
export const afterEach: typeof test.afterEach.always.skip;
|
|
1570
|
+
export const cb: typeof test.always.cb.skip;
|
|
1571
|
+
}
|
|
1572
|
+
export namespace test.always.todo {
|
|
1573
|
+
export const serial: typeof test.always.serial.todo;
|
|
1574
|
+
export const after: typeof test.after.always.todo;
|
|
1575
|
+
export const failing: typeof test.always.failing.todo;
|
|
1576
|
+
export const afterEach: typeof test.afterEach.always.todo;
|
|
1577
|
+
export const cb: typeof test.always.cb.todo;
|
|
1578
|
+
}
|
|
1579
|
+
export namespace test.always.failing {
|
|
1580
|
+
export const after: typeof test.after.always.failing;
|
|
1581
|
+
export const afterEach: typeof test.afterEach.always.failing;
|
|
1582
|
+
export const cb: typeof test.always.cb.failing;
|
|
1583
|
+
}
|
|
1584
|
+
export namespace test.always.failing.serial {
|
|
1585
|
+
export const after: typeof test.after.always.failing.serial;
|
|
1586
|
+
export const afterEach: typeof test.afterEach.always.failing.serial;
|
|
1587
|
+
export const cb: typeof test.always.cb.failing.serial;
|
|
1588
|
+
}
|
|
1589
|
+
export namespace test.always.failing.serial.skip {
|
|
1590
|
+
export const after: typeof test.after.always.failing.serial.skip;
|
|
1591
|
+
export const afterEach: typeof test.afterEach.always.failing.serial.skip;
|
|
1592
|
+
export const cb: typeof test.always.cb.failing.serial.skip;
|
|
1593
|
+
}
|
|
1594
|
+
export namespace test.always.failing.serial.todo {
|
|
1595
|
+
export const after: typeof test.after.always.failing.serial.todo;
|
|
1596
|
+
export const afterEach: typeof test.afterEach.always.failing.serial.todo;
|
|
1597
|
+
export const cb: typeof test.always.cb.failing.serial.todo;
|
|
1598
|
+
}
|
|
1599
|
+
export namespace test.always.failing.skip {
|
|
1600
|
+
export const serial: typeof test.always.failing.serial.skip;
|
|
1601
|
+
export const after: typeof test.after.always.failing.skip;
|
|
1602
|
+
export const afterEach: typeof test.afterEach.always.failing.skip;
|
|
1603
|
+
export const cb: typeof test.always.cb.failing.skip;
|
|
1604
|
+
}
|
|
1605
|
+
export namespace test.always.failing.todo {
|
|
1606
|
+
export const serial: typeof test.always.failing.serial.todo;
|
|
1607
|
+
export const after: typeof test.after.always.failing.todo;
|
|
1608
|
+
export const afterEach: typeof test.afterEach.always.failing.todo;
|
|
1609
|
+
export const cb: typeof test.always.cb.failing.todo;
|
|
1610
|
+
}
|
|
1611
|
+
export namespace test.always.cb {
|
|
1612
|
+
export const after: typeof test.after.always.cb;
|
|
1613
|
+
export const afterEach: typeof test.afterEach.always.cb;
|
|
1614
|
+
}
|
|
1615
|
+
export namespace test.always.cb.serial {
|
|
1616
|
+
export const after: typeof test.after.always.cb.serial;
|
|
1617
|
+
export const failing: typeof test.always.cb.failing.serial;
|
|
1618
|
+
export const afterEach: typeof test.afterEach.always.cb.serial;
|
|
1619
|
+
}
|
|
1620
|
+
export namespace test.always.cb.serial.skip {
|
|
1621
|
+
export const after: typeof test.after.always.cb.serial.skip;
|
|
1622
|
+
export const failing: typeof test.always.cb.failing.serial.skip;
|
|
1623
|
+
export const afterEach: typeof test.afterEach.always.cb.serial.skip;
|
|
1624
|
+
}
|
|
1625
|
+
export namespace test.always.cb.serial.todo {
|
|
1626
|
+
export const after: typeof test.after.always.cb.serial.todo;
|
|
1627
|
+
export const failing: typeof test.always.cb.failing.serial.todo;
|
|
1628
|
+
export const afterEach: typeof test.afterEach.always.cb.serial.todo;
|
|
1629
|
+
}
|
|
1630
|
+
export namespace test.always.cb.skip {
|
|
1631
|
+
export const serial: typeof test.always.cb.serial.skip;
|
|
1632
|
+
export const after: typeof test.after.always.cb.skip;
|
|
1633
|
+
export const failing: typeof test.always.cb.failing.skip;
|
|
1634
|
+
export const afterEach: typeof test.afterEach.always.cb.skip;
|
|
1635
|
+
}
|
|
1636
|
+
export namespace test.always.cb.todo {
|
|
1637
|
+
export const serial: typeof test.always.cb.serial.todo;
|
|
1638
|
+
export const after: typeof test.after.always.cb.todo;
|
|
1639
|
+
export const failing: typeof test.always.cb.failing.todo;
|
|
1640
|
+
export const afterEach: typeof test.afterEach.always.cb.todo;
|
|
1641
|
+
}
|
|
1642
|
+
export namespace test.always.cb.failing {
|
|
1643
|
+
export const after: typeof test.after.always.cb.failing;
|
|
1644
|
+
export const afterEach: typeof test.afterEach.always.cb.failing;
|
|
1645
|
+
}
|
|
1646
|
+
export namespace test.always.cb.failing.serial {
|
|
1647
|
+
export const after: typeof test.after.always.cb.failing.serial;
|
|
1648
|
+
export const afterEach: typeof test.afterEach.always.cb.failing.serial;
|
|
1649
|
+
}
|
|
1650
|
+
export namespace test.always.cb.failing.serial.skip {
|
|
1651
|
+
export const after: typeof test.after.always.cb.failing.serial.skip;
|
|
1652
|
+
export const afterEach: typeof test.afterEach.always.cb.failing.serial.skip;
|
|
1653
|
+
}
|
|
1654
|
+
export namespace test.always.cb.failing.serial.todo {
|
|
1655
|
+
export const after: typeof test.after.always.cb.failing.serial.todo;
|
|
1656
|
+
export const afterEach: typeof test.afterEach.always.cb.failing.serial.todo;
|
|
1657
|
+
}
|
|
1658
|
+
export namespace test.always.cb.failing.skip {
|
|
1659
|
+
export const serial: typeof test.always.cb.failing.serial.skip;
|
|
1660
|
+
export const after: typeof test.after.always.cb.failing.skip;
|
|
1661
|
+
export const afterEach: typeof test.afterEach.always.cb.failing.skip;
|
|
1662
|
+
}
|
|
1663
|
+
export namespace test.always.cb.failing.todo {
|
|
1664
|
+
export const serial: typeof test.always.cb.failing.serial.todo;
|
|
1665
|
+
export const after: typeof test.after.always.cb.failing.todo;
|
|
1666
|
+
export const afterEach: typeof test.afterEach.always.cb.failing.todo;
|
|
1667
|
+
}
|