How to use notThrowsAsyncFails method in ava

...94			assertFailure(t, subset);95		});96	});97}98function notThrowsAsyncFails(t, fn, subset) {99	return add(() => {100		lastFailure = null;101		return fn().then(retval => {102			t.equal(retval, undefined);103			assertFailure(t, subset);104		});105	});106}107function fails(t, fn) {108	lastFailure = null;109	const retval = fn();110	if (lastFailure) {111		t.notOk(retval);112	} else {113		t.fail('Expected assertion to fail');114	}115}116function passes(t, fn, {expectBoolean = true} = {}) {117	lastPassed = false;118	lastFailure = null;119	const retval = fn();120	if (lastPassed) {121		if (expectBoolean) {122			t.ok(retval);123		} else {124			t.pass();125		}126	} else {127		t.error(lastFailure, 'Expected assertion to pass');128	}129}130function throwsAsyncPasses(t, fn) {131	return add(() => {132		lastPassed = false;133		lastFailure = null;134		return fn().then(() => {135			if (lastPassed) {136				t.pass();137			} else {138				t.error(lastFailure, 'Expected assertion to pass');139			}140		});141	});142}143const notThrowsAsyncPasses = throwsAsyncPasses;144test('.pass()', t => {145	passes(t, () => assertions.pass());146	passes(t, () => assertions.pass());147	t.end();148});149test('.fail()', t => {150	failsWith(t, () => assertions.fail(), {151		assertion: 'fail',152		message: 'Test failed via `t.fail()`',153	});154	failsWith(t, () => assertions.fail('my message'), {155		assertion: 'fail',156		message: 'my message',157	});158	failsWith(t, () => assertions.fail(), {159		assertion: 'fail',160		message: 'Test failed via `t.fail()`',161	});162	failsWith(t, () => assertions.fail(null), {163		assertion: 'fail',164		improperUsage: true,165		message: 'The assertion message must be a string',166		values: [{167			label: 'Called with:',168			formatted: /null/,169		}],170	});171	t.end();172});173test('.is()', t => {174	passes(t, () => assertions.is('foo', 'foo'));175	passes(t, () => assertions.is('foo', 'foo'));176	passes(t, () => assertions.is('', ''));177	passes(t, () => assertions.is(true, true));178	passes(t, () => assertions.is(false, false));179	passes(t, () => assertions.is(null, null));180	passes(t, () => assertions.is(undefined, undefined));181	passes(t, () => assertions.is(1, 1));182	passes(t, () => assertions.is(0, 0));183	passes(t, () => assertions.is(-0, -0));184	passes(t, () => assertions.is(Number.NaN, Number.NaN));185	passes(t, () => assertions.is(0 / 0, Number.NaN));186	passes(t, () => {187		const someRef = {foo: 'bar'};188		return assertions.is(someRef, someRef);189	});190	fails(t, () => assertions.is(0, -0));191	fails(t, () => assertions.is(0, false));192	fails(t, () => assertions.is('', false));193	fails(t, () => assertions.is('0', 0));194	fails(t, () => assertions.is('17', 17));195	fails(t, () => assertions.is([1, 2], '1,2'));196	fails(t, () =>197		// eslint-disable-next-line no-new-wrappers, unicorn/new-for-builtins198		assertions.is(new String('foo'), 'foo'),199	);200	fails(t, () => assertions.is(null, undefined));201	fails(t, () => assertions.is(null, false));202	fails(t, () => assertions.is(undefined, false));203	fails(t, () =>204		// eslint-disable-next-line no-new-wrappers, unicorn/new-for-builtins205		assertions.is(new String('foo'), new String('foo')),206	);207	fails(t, () => assertions.is(0, null));208	fails(t, () => assertions.is(0, Number.NaN));209	fails(t, () => assertions.is('foo', Number.NaN));210	failsWith(t, () => assertions.is({foo: 'bar'}, {foo: 'bar'}), {211		assertion: 'is',212		message: '',213		actual: {foo: 'bar'},214		expected: {foo: 'bar'},215		values: [{216			label: 'Values are deeply equal to each other, but they are not the same:',217			formatted: /foo/,218		}],219	});220	failsWith(t, () => assertions.is('foo', 'bar'), {221		assertion: 'is',222		message: '',223		raw: {actual: 'foo', expected: 'bar'},224		values: [225			{label: 'Difference:', formatted: /- 'foo'\n\+ 'bar'/},226		],227	});228	failsWith(t, () => assertions.is('foo', 42), {229		actual: 'foo',230		assertion: 'is',231		expected: 42,232		message: '',233		values: [234			{label: 'Difference:', formatted: /- 'foo'\n\+ 42/},235		],236	});237	failsWith(t, () => assertions.is('foo', 42, 'my message'), {238		assertion: 'is',239		message: 'my message',240		values: [241			{label: 'Difference:', formatted: /- 'foo'\n\+ 42/},242		],243	});244	failsWith(t, () => assertions.is(0, -0, 'my message'), {245		assertion: 'is',246		message: 'my message',247		values: [248			{label: 'Difference:', formatted: /- 0\n\+ -0/},249		],250	});251	failsWith(t, () => assertions.is(-0, 0, 'my message'), {252		assertion: 'is',253		message: 'my message',254		values: [255			{label: 'Difference:', formatted: /- -0\n\+ 0/},256		],257	});258	failsWith(t, () => assertions.is(0, 0, null), {259		assertion: 'is',260		improperUsage: true,261		message: 'The assertion message must be a string',262		values: [{263			label: 'Called with:',264			formatted: /null/,265		}],266	});267	t.end();268});269test('.not()', t => {270	passes(t, () => assertions.not('foo', 'bar'));271	passes(t, () => assertions.not('foo', 'bar'));272	fails(t, () => assertions.not(Number.NaN, Number.NaN));273	fails(t, () => assertions.not(0 / 0, Number.NaN));274	failsWith(t, () => assertions.not('foo', 'foo'), {275		assertion: 'not',276		message: '',277		raw: {actual: 'foo', expected: 'foo'},278		values: [{label: 'Value is the same as:', formatted: /foo/}],279	});280	failsWith(t, () => assertions.not('foo', 'foo', 'my message'), {281		assertion: 'not',282		message: 'my message',283		values: [{label: 'Value is the same as:', formatted: /foo/}],284	});285	failsWith(t, () => assertions.not(0, 1, null), {286		assertion: 'not',287		improperUsage: true,288		message: 'The assertion message must be a string',289		values: [{290			label: 'Called with:',291			formatted: /null/,292		}],293	});294	t.end();295});296test('.deepEqual()', t => {297	// Tests starting here are to detect regressions in the underlying libraries298	// used to test deep object equality299	fails(t, () => assertions.deepEqual({a: false}, {a: 0}));300	passes(t, () => assertions.deepEqual({301		a: 'a',302		b: 'b',303	}, {304		b: 'b',305		a: 'a',306	}));307	passes(t, () => assertions.deepEqual({a: 'a', b: 'b'}, {b: 'b', a: 'a'}));308	passes(t, () => assertions.deepEqual({309		a: 'a',310		b: 'b',311		c: {312			d: 'd',313		},314	}, {315		c: {316			d: 'd',317		},318		b: 'b',319		a: 'a',320	}));321	fails(t, () => assertions.deepEqual([1, 2, 3], [1, 2, 3, 4]));322	passes(t, () => assertions.deepEqual([1, 2, 3], [1, 2, 3]));323	fails(t, () => {324		const fnA = a => a;325		const fnB = a => a;326		return assertions.deepEqual(fnA, fnB);327	});328	passes(t, () => {329		const x1 = {z: 4};330		const y1 = {x: x1};331		x1.y = y1;332		const x2 = {z: 4};333		const y2 = {x: x2};334		x2.y = y2;335		return assertions.deepEqual(x1, x2);336	});337	passes(t, () => {338		function Foo(a) {339			this.a = a;340		}341		const x = new Foo(1);342		const y = new Foo(1);343		return assertions.deepEqual(x, y);344	});345	fails(t, () => {346		function Foo(a) {347			this.a = a;348		}349		function Bar(a) {350			this.a = a;351		}352		const x = new Foo(1);353		const y = new Bar(1);354		return assertions.deepEqual(x, y);355	});356	fails(t, () => assertions.deepEqual({357		a: 'a',358		b: 'b',359		c: {360			d: false,361		},362	}, {363		c: {364			d: 0,365		},366		b: 'b',367		a: 'a',368	}));369	fails(t, () => assertions.deepEqual({}, []));370	fails(t, () => assertions.deepEqual({0: 'a', 1: 'b'}, ['a', 'b']));371	fails(t, () => assertions.deepEqual({a: 1}, {a: 1, b: undefined}));372	fails(t, () => assertions.deepEqual(new Date('1972-08-01'), null));373	fails(t, () => assertions.deepEqual(new Date('1972-08-01'), undefined));374	passes(t, () => assertions.deepEqual(new Date('1972-08-01'), new Date('1972-08-01')));375	passes(t, () => assertions.deepEqual({x: new Date('1972-08-01')}, {x: new Date('1972-08-01')}));376	fails(t, () => assertions.deepEqual(() => {}, () => {}));377	passes(t, () => assertions.deepEqual(undefined, undefined)378            && assertions.deepEqual({x: undefined}, {x: undefined})379            && assertions.deepEqual({x: [undefined]}, {x: [undefined]}));380	passes(t, () => assertions.deepEqual(null, null)381            && assertions.deepEqual({x: null}, {x: null})382            && assertions.deepEqual({x: [null]}, {x: [null]}));383	passes(t, () => assertions.deepEqual(0, 0)384            && assertions.deepEqual(1, 1)385            && assertions.deepEqual(3.14, 3.14));386	fails(t, () => assertions.deepEqual(0, 1));387	fails(t, () => assertions.deepEqual(1, -1));388	fails(t, () => assertions.deepEqual(3.14, 2.72));389	fails(t, () => assertions.deepEqual({0: 'a', 1: 'b'}, ['a', 'b']));390	passes(t, () => assertions.deepEqual(391		[392			{foo: {z: 100, y: 200, x: 300}},393			'bar',394			11,395			{baz: {d: 4, a: 1, b: 2, c: 3}},396		],397		[398			{foo: {x: 300, y: 200, z: 100}},399			'bar',400			11,401			{baz: {c: 3, b: 2, a: 1, d: 4}},402		],403	));404	passes(t, () => assertions.deepEqual(405		{x: {a: 1, b: 2}, y: {c: 3, d: 4}},406		{y: {d: 4, c: 3}, x: {b: 2, a: 1}},407	));408	// Regression test end here409	passes(t, () => assertions.deepEqual({a: 'a'}, {a: 'a'}));410	passes(t, () => assertions.deepEqual(['a', 'b'], ['a', 'b']));411	fails(t, () => assertions.deepEqual({a: 'a'}, {a: 'b'}));412	fails(t, () => assertions.deepEqual(['a', 'b'], ['a', 'a']));413	fails(t, () => assertions.deepEqual([['a', 'b'], 'c'], [['a', 'b'], 'd']));414	fails(t, () => {415		const circular = ['a', 'b'];416		circular.push(circular);417		return assertions.deepEqual([circular, 'c'], [circular, 'd']);418	});419	failsWith(t, () => assertions.deepEqual('foo', 'bar'), {420		assertion: 'deepEqual',421		message: '',422		raw: {actual: 'foo', expected: 'bar'},423		values: [{label: 'Difference:', formatted: /- 'foo'\n\+ 'bar'/}],424	});425	failsWith(t, () => assertions.deepEqual('foo', 42), {426		assertion: 'deepEqual',427		message: '',428		raw: {actual: 'foo', expected: 42},429		values: [{label: 'Difference:', formatted: /- 'foo'\n\+ 42/}],430	});431	failsWith(t, () => assertions.deepEqual('foo', 42, 'my message'), {432		assertion: 'deepEqual',433		message: 'my message',434		values: [{label: 'Difference:', formatted: /- 'foo'\n\+ 42/}],435	});436	failsWith(t, () => assertions.deepEqual({}, {}, null), {437		assertion: 'deepEqual',438		improperUsage: true,439		message: 'The assertion message must be a string',440		values: [{441			label: 'Called with:',442			formatted: /null/,443		}],444	});445	t.end();446});447test('.notDeepEqual()', t => {448	passes(t, () => assertions.notDeepEqual({a: 'a'}, {a: 'b'}));449	passes(t, () => assertions.notDeepEqual({a: 'a'}, {a: 'b'}));450	passes(t, () => assertions.notDeepEqual(['a', 'b'], ['c', 'd']));451	const actual = {a: 'a'};452	const expected = {a: 'a'};453	failsWith(t, () => assertions.notDeepEqual(actual, expected), {454		actual,455		assertion: 'notDeepEqual',456		expected,457		message: '',458		raw: {actual, expected},459		values: [{label: 'Value is deeply equal:', formatted: /.*{.*\n.*a: 'a'/}],460	});461	failsWith(t, () => assertions.notDeepEqual(['a', 'b'], ['a', 'b'], 'my message'), {462		assertion: 'notDeepEqual',463		message: 'my message',464		values: [{label: 'Value is deeply equal:', formatted: /.*\[.*\n.*'a',\n.*'b',/}],465	});466	failsWith(t, () => assertions.notDeepEqual({}, [], null), {467		assertion: 'notDeepEqual',468		improperUsage: true,469		message: 'The assertion message must be a string',470		values: [{471			label: 'Called with:',472			formatted: /null/,473		}],474	});475	t.end();476});477test('.like()', t => {478	fails(t, () => assertions.like({a: false}, {a: 0}));479	passes(t, () => assertions.like({480		a: 'a',481		b: 'b',482	}, {483		b: 'b',484		a: 'a',485	}));486	passes(t, () => assertions.like({a: 'a', b: 'b'}, {b: 'b', a: 'a'}));487	passes(t, () => assertions.like({488		a: 'a',489		b: 'b',490		c: {491			d: 'd',492			x: 'x',493		},494		x: 'x',495	}, {496		c: {497			d: 'd',498		},499		b: 'b',500		a: 'a',501	}));502	fails(t, () => assertions.like([1, 2, 3], [1, 2, 3, 4]));503	fails(t, () => assertions.like({504		a: [1, 2, 3],505	}, {506		a: [1, 2, 3, 4],507	}));508	passes(t, () => assertions.like({509		a: [1, 2, 3],510		x: 'x',511	}, {512		a: [1, 2, 3],513	}));514	passes(t, () => {515		const actual = {516			a: 'a',517			extra: 'irrelevant',518		};519		actual.circular = actual;520		const likePattern = {521			a: 'a',522		};523		return assertions.like(actual, likePattern);524	});525	fails(t, () => {526		const fnA = a => a;527		const fnB = a => a;528		return assertions.like(fnA, fnB);529	});530	fails(t, () => {531		const fnA = a => a;532		const fnB = a => a;533		return assertions.like({534			fn: fnA,535		}, {536			fn: fnB,537		});538	});539	fails(t, () => {540		function Foo(a) {541			this.a = a;542		}543		function Bar(a) {544			this.a = a;545		}546		const x = new Foo(1);547		const y = new Bar(1);548		return assertions.like(x, y);549	});550	passes(t, () => assertions.like({a: 'a'}, {a: 'a'}));551	passes(t, () => assertions.like({a: 'a', b: 'b'}, {a: 'a'}));552	passes(t, () => assertions.like({ab: ['a', 'b']}, {ab: ['a', 'b']}));553	passes(t, () => assertions.like({ab: ['a', 'b'], c: 'c'}, {ab: ['a', 'b']}));554	fails(t, () => assertions.like({a: 'a'}, {a: 'b'}));555	fails(t, () => assertions.like({a: 'a', b: 'b'}, {a: 'b'}));556	fails(t, () => assertions.like({ab: ['a', 'b']}, {ab: ['a', 'a']}));557	fails(t, () => assertions.like({ab: ['a', 'b'], c: 'c'}, {ab: ['a', 'a']}));558	fails(t, () => assertions.like([['a', 'b'], 'c'], [['a', 'b'], 'd']));559	fails(t, () => {560		const circular = ['a', 'b'];561		circular.push(circular);562		return assertions.like([circular, 'c'], [circular, 'd']);563	});564	fails(t, () => {565		const circular = ['a', 'b'];566		circular.push(circular);567		return assertions.like({xc: [circular, 'c']}, {xc: [circular, 'd']});568	});569	failsWith(t, () => assertions.like({a: 'a'}, {}), {570		assertion: 'like',571		message: '`t.like()` selector must be a non-empty object',572		values: [{label: 'Called with:', formatted: '{}'}],573	});574	failsWith(t, () => assertions.like('foo', 'bar'), {575		assertion: 'like',576		message: '`t.like()` selector must be a non-empty object',577		values: [{label: 'Called with:', formatted: '\'bar\''}],578	});579	failsWith(t, () => {580		const likePattern = {581			a: 'a',582		};583		likePattern.circular = likePattern;584		return assertions.like({}, likePattern);585	}, {586		assertion: 'like',587		message: '`t.like()` selector must not contain circular references',588		values: [{label: 'Called with:', formatted: '{\n  a: \'a\',\n  circular: [Circular],\n}'}],589	});590	failsWith(t, () => assertions.like({}, {}, null), {591		assertion: 'like',592		improperUsage: true,593		message: 'The assertion message must be a string',594		values: [{595			label: 'Called with:',596			formatted: /null/,597		}],598	});599	failsWith(t, () => assertions.like({a: 'foo', b: 'irrelevant'}, {a: 'bar'}), {600		assertion: 'like',601		message: '',602		values: [{label: 'Difference:', formatted: /{\n-\s*a: 'foo',\n\+\s*a: 'bar',\n\s*}/}],603	});604	t.end();605});606test('.throws()', gather(t => {607	// Fails because function doesn't throw.608	failsWith(t, () => assertions.throws(() => {}), {609		assertion: 'throws',610		message: '',611		values: [{label: 'Function returned:', formatted: /undefined/}],612	});613	failsWith(t, () => assertions.throws(() => {}), {614		assertion: 'throws',615		message: '',616		values: [{label: 'Function returned:', formatted: /undefined/}],617	});618	// Fails because function doesn't throw. Asserts that 'my message' is used619	// as the assertion message (*not* compared against the error).620	failsWith(t, () => assertions.throws(() => {}, undefined, 'my message'), {621		assertion: 'throws',622		message: 'my message',623		values: [{label: 'Function returned:', formatted: /undefined/}],624	});625	// Fails because the function returned a promise.626	failsWith(t, () => assertions.throws(() => Promise.resolve()), {627		assertion: 'throws',628		message: '',629		values: [{label: 'Function returned a promise. Use `t.throwsAsync()` instead:', formatted: /Promise/}],630	});631	// Fails because thrown exception is not an error632	failsWith(t, () => assertions.throws(() => {633		const error = 'foo';634		throw error;635	}), {636		assertion: 'throws',637		message: '',638		values: [639			{label: 'Function threw exception that is not an error:', formatted: /'foo'/},640		],641	});642	// Passes because an error is thrown.643	passes(t, () => assertions.throws(() => {644		throw new Error('foo');645	}));646	// Passes because the correct error is thrown.647	passes(t, () => {648		const error = new Error('foo');649		return assertions.throws(() => {650			throw error;651		}, {is: error});652	});653	// Fails because the thrown value is not an error654	fails(t, () => {655		const object = {};656		return assertions.throws(() => {657			throw object;658		}, {is: object});659	});660	// Fails because the thrown value is not the right one661	fails(t, () => {662		const error = new Error('foo');663		return assertions.throws(() => {664			throw error;665		}, {is: {}});666	});667	// Passes because the correct error is thrown.668	passes(t, () => assertions.throws(() => {669		throw new TypeError();670	}, {name: 'TypeError'}));671	// Fails because the thrown value is not an error672	fails(t, () => assertions.throws(() => {673		const error = {name: 'Bob'};674		throw error;675	}, {name: 'Bob'}));676	// Fails because the thrown value is not the right one677	fails(t, () => assertions.throws(() => {678		throw new Error('foo');679	}, {name: 'TypeError'}));680	// Passes because the correct error is thrown.681	passes(t, () => assertions.throws(() => {682		const error = new TypeError();683		error.code = 'ERR_TEST';684		throw error;685	}, {code: 'ERR_TEST'}));686	// Passes because the correct error is thrown.687	passes(t, () => assertions.throws(() => {688		const error = new TypeError();689		error.code = 42;690		throw error;691	}, {code: 42}));692	// Fails because the thrown value is not the right one693	fails(t, () => assertions.throws(() => {694		const error = new TypeError();695		error.code = 'ERR_NOPE';696		throw error;697	}, {code: 'ERR_TEST'}));698	fails(t, () => assertions.throws(() => {699		const error = new TypeError();700		error.code = 1;701		throw error;702	}, {code: 42}));703	// Regression test for https://github.com/avajs/ava/issues/1676704	fails(t, () => assertions.throws(() => {705		throw new Error('foo');706	}, false));707	passes(t, () => assertions.throws(() => {708		throw new Error('foo');709	}, undefined));710	passes(t, async () => {711		await assertions.throwsAsync(() => Promise.reject(new Error('foo')), undefined);712	});713	failsWith(t, () => assertions.throws(() => {}, undefined, null), {714		assertion: 'throws',715		improperUsage: true,716		message: 'The assertion message must be a string',717		values: [{718			label: 'Called with:',719			formatted: /null/,720		}],721	});722	// Fails because the string in the message is incorrect723	failsWith(724		t,725		() =>726			assertions.throws(727				() => {728					throw new Error('error');729				},730				{message: 'my error'},731			),732		{733			assertion: 'throws',734			message: '',735			values: [736				{label: 'Function threw unexpected exception:', formatted: /error/},737				{label: 'Expected message to equal:', formatted: /my error/},738			],739		},740	);741	passes(t, () => assertions.throws(() => {742		throw new Error('error');743	}, {message: 'error'}));744	// Fails because the regular expression in the message is incorrect745	failsWith(746		t,747		() =>748			assertions.throws(749				() => {750					throw new Error('error');751				},752				{message: /my error/},753			),754		{755			assertion: 'throws',756			message: '',757			values: [758				{label: 'Function threw unexpected exception:', formatted: /error/},759				{label: 'Expected message to match:', formatted: /my error/},760			],761		},762	);763	passes(t, () => assertions.throws(() => {764		throw new Error('error');765	}, {message: /error/}));766	// Fails because the function in the message returns false767	failsWith(768		t,769		() =>770			assertions.throws(771				() => {772					throw new Error('error');773				},774				{message: () => false},775			),776		{777			assertion: 'throws',778			message: '',779			values: [780				{label: 'Function threw unexpected exception:', formatted: /error/},781				{label: 'Expected message to return true:', formatted: /Function/},782			],783		},784	);785	passes(t, () => assertions.throws(() => {786		throw new Error('error');787	}, {message: () => true}));788}));789test('.throws() returns the thrown error', t => {790	const expected = new Error();791	const actual = assertions.throws(() => {792		throw expected;793	});794	t.equal(actual, expected);795	t.end();796});797test('.throwsAsync()', gather(t => {798	// Fails because the promise is resolved, not rejected.799	throwsAsyncFails(t, () => assertions.throwsAsync(Promise.resolve('foo')), {800		assertion: 'throwsAsync',801		message: '',802		values: [{label: 'Promise resolved with:', formatted: /'foo'/}],803	});804	throwsAsyncFails(t, () => assertions.throwsAsync(Promise.resolve('foo')), {805		assertion: 'throwsAsync',806		message: '',807		values: [{label: 'Promise resolved with:', formatted: /'foo'/}],808	});809	// Fails because the promise is resolved with an Error810	throwsAsyncFails(t, () => assertions.throwsAsync(Promise.resolve(new Error())), {811		assertion: 'throwsAsync',812		message: '',813		values: [{label: 'Promise resolved with:', formatted: /Error/}],814	});815	// Fails because the function returned a promise that resolved, not rejected.816	throwsAsyncFails(t, () => assertions.throwsAsync(() => Promise.resolve('foo')), {817		assertion: 'throwsAsync',818		message: '',819		values: [{label: 'Returned promise resolved with:', formatted: /'foo'/}],820	});821	// Passes because the promise was rejected with an error.822	throwsAsyncPasses(t, () => assertions.throwsAsync(Promise.reject(new Error())));823	// Passes because the function returned a promise rejected with an error.824	throwsAsyncPasses(t, () => assertions.throwsAsync(() => Promise.reject(new Error())));825	// Fails because the function throws synchronously826	throwsAsyncFails(t, () => assertions.throwsAsync(() => {827		throw new Error('sync');828	}, undefined, 'message'), {829		assertion: 'throwsAsync',830		message: 'message',831		values: [832			{label: 'Function threw synchronously. Use `t.throws()` instead:', formatted: /Error/},833		],834	});835	// Fails because the function did not return a promise836	throwsAsyncFails(t, () => assertions.throwsAsync(() => {}, undefined, 'message'), {837		assertion: 'throwsAsync',838		message: 'message',839		values: [840			{label: 'Function returned:', formatted: /undefined/},841		],842	});843	throwsAsyncFails(t, () => assertions.throwsAsync(Promise.resolve(), undefined, null), {844		assertion: 'throwsAsync',845		improperUsage: true,846		message: 'The assertion message must be a string',847		values: [{848			label: 'Called with:',849			formatted: /null/,850		}],851	});852}));853test('.throwsAsync() returns the rejection reason of promise', t => {854	const expected = new Error();855	return assertions.throwsAsync(Promise.reject(expected)).then(actual => {856		t.equal(actual, expected);857		t.end();858	});859});860test('.throwsAsync() returns the rejection reason of a promise returned by the function', t => {861	const expected = new Error();862	return assertions.throwsAsync(() => Promise.reject(expected)).then(actual => {863		t.equal(actual, expected);864		t.end();865	});866});867test('.throws() fails if passed a bad value', t => {868	failsWith(t, () => assertions.throws('not a function'), {869		assertion: 'throws',870		message: '`t.throws()` must be called with a function',871		values: [{label: 'Called with:', formatted: /not a function/}],872	});873	t.end();874});875test('.throwsAsync() fails if passed a bad value', t => {876	failsWith(t, () => assertions.throwsAsync('not a function'), {877		assertion: 'throwsAsync',878		message: '`t.throwsAsync()` must be called with a function or promise',879		values: [{label: 'Called with:', formatted: /not a function/}],880	}, {expectBoolean: false});881	t.end();882});883test('.throws() fails if passed a bad expectation', t => {884	failsWith(t, () => assertions.throws(() => {}, true), {885		assertion: 'throws',886		message: 'The second argument to `t.throws()` must be an expectation object, `null` or `undefined`',887		values: [{label: 'Called with:', formatted: /true/}],888	});889	failsWith(t, () => assertions.throws(() => {}, 'foo'), {890		assertion: 'throws',891		message: 'The second argument to `t.throws()` must be an expectation object, `null` or `undefined`',892		values: [{label: 'Called with:', formatted: /foo/}],893	});894	failsWith(t, () => assertions.throws(() => {}, /baz/), {895		assertion: 'throws',896		message: 'The second argument to `t.throws()` must be an expectation object, `null` or `undefined`',897		values: [{label: 'Called with:', formatted: /baz/}],898	});899	failsWith(t, () => assertions.throws(() => {}, class Bar {}), {900		assertion: 'throws',901		message: 'The second argument to `t.throws()` must be an expectation object, `null` or `undefined`',902		values: [{label: 'Called with:', formatted: /Bar/}],903	});904	failsWith(t, () => assertions.throws(() => {}, {}), {905		assertion: 'throws',906		message: 'The second argument to `t.throws()` must be an expectation object, `null` or `undefined`',907		values: [{label: 'Called with:', formatted: /{}/}],908	});909	failsWith(t, () => assertions.throws(() => {}, []), {910		assertion: 'throws',911		message: 'The second argument to `t.throws()` must be an expectation object, `null` or `undefined`',912		values: [{label: 'Called with:', formatted: /\[]/}],913	});914	failsWith(t, () => assertions.throws(() => {}, {code: {}}), {915		assertion: 'throws',916		message: 'The `code` property of the second argument to `t.throws()` must be a string or number',917		values: [{label: 'Called with:', formatted: /code: {}/}],918	});919	failsWith(t, () => assertions.throws(() => {}, {instanceOf: null}), {920		assertion: 'throws',921		message: 'The `instanceOf` property of the second argument to `t.throws()` must be a function',922		values: [{label: 'Called with:', formatted: /instanceOf: null/}],923	});924	failsWith(t, () => assertions.throws(() => {}, {message: null}), {925		assertion: 'throws',926		message: 'The `message` property of the second argument to `t.throws()` must be a string, regular expression or a function',927		values: [{label: 'Called with:', formatted: /message: null/}],928	});929	failsWith(t, () => assertions.throws(() => {}, {name: null}), {930		assertion: 'throws',931		message: 'The `name` property of the second argument to `t.throws()` must be a string',932		values: [{label: 'Called with:', formatted: /name: null/}],933	});934	failsWith(t, () => assertions.throws(() => {}, {is: {}, message: '', name: '', of() {}, foo: null}), {935		assertion: 'throws',936		message: 'The second argument to `t.throws()` contains unexpected properties',937		values: [{label: 'Called with:', formatted: /foo: null/}],938	});939	t.end();940});941test('.throwsAsync() fails if passed a bad expectation', t => {942	failsWith(t, () => assertions.throwsAsync(() => {}, true), {943		assertion: 'throwsAsync',944		message: 'The second argument to `t.throwsAsync()` must be an expectation object, `null` or `undefined`',945		values: [{label: 'Called with:', formatted: /true/}],946	}, {expectBoolean: false});947	failsWith(t, () => assertions.throwsAsync(() => {}, 'foo'), {948		assertion: 'throwsAsync',949		message: 'The second argument to `t.throwsAsync()` must be an expectation object, `null` or `undefined`',950		values: [{label: 'Called with:', formatted: /foo/}],951	}, {expectBoolean: false});952	failsWith(t, () => assertions.throwsAsync(() => {}, /baz/), {953		assertion: 'throwsAsync',954		message: 'The second argument to `t.throwsAsync()` must be an expectation object, `null` or `undefined`',955		values: [{label: 'Called with:', formatted: /baz/}],956	}, {expectBoolean: false});957	failsWith(t, () => assertions.throwsAsync(() => {}, class Bar {}), {958		assertion: 'throwsAsync',959		message: 'The second argument to `t.throwsAsync()` must be an expectation object, `null` or `undefined`',960		values: [{label: 'Called with:', formatted: /Bar/}],961	}, {expectBoolean: false});962	failsWith(t, () => assertions.throwsAsync(() => {}, {}), {963		assertion: 'throwsAsync',964		message: 'The second argument to `t.throwsAsync()` must be an expectation object, `null` or `undefined`',965		values: [{label: 'Called with:', formatted: /{}/}],966	}, {expectBoolean: false});967	failsWith(t, () => assertions.throwsAsync(() => {}, []), {968		assertion: 'throwsAsync',969		message: 'The second argument to `t.throwsAsync()` must be an expectation object, `null` or `undefined`',970		values: [{label: 'Called with:', formatted: /\[]/}],971	}, {expectBoolean: false});972	failsWith(t, () => assertions.throwsAsync(() => {}, {code: {}}), {973		assertion: 'throwsAsync',974		message: 'The `code` property of the second argument to `t.throwsAsync()` must be a string or number',975		values: [{label: 'Called with:', formatted: /code: {}/}],976	}, {expectBoolean: false});977	failsWith(t, () => assertions.throwsAsync(() => {}, {instanceOf: null}), {978		assertion: 'throwsAsync',979		message: 'The `instanceOf` property of the second argument to `t.throwsAsync()` must be a function',980		values: [{label: 'Called with:', formatted: /instanceOf: null/}],981	}, {expectBoolean: false});982	failsWith(t, () => assertions.throwsAsync(() => {}, {message: null}), {983		assertion: 'throwsAsync',984		message: 'The `message` property of the second argument to `t.throwsAsync()` must be a string, regular expression or a function',985		values: [{label: 'Called with:', formatted: /message: null/}],986	}, {expectBoolean: false});987	failsWith(t, () => assertions.throwsAsync(() => {}, {name: null}), {988		assertion: 'throwsAsync',989		message: 'The `name` property of the second argument to `t.throwsAsync()` must be a string',990		values: [{label: 'Called with:', formatted: /name: null/}],991	}, {expectBoolean: false});992	failsWith(t, () => assertions.throwsAsync(() => {}, {is: {}, message: '', name: '', of() {}, foo: null}), {993		assertion: 'throwsAsync',994		message: 'The second argument to `t.throwsAsync()` contains unexpected properties',995		values: [{label: 'Called with:', formatted: /foo: null/}],996	}, {expectBoolean: false});997	t.end();998});999test('.throws() fails if passed null expectation', t => {1000	const asserter = new AssertionsBase();1001	failsWith(t, () => {1002		asserter.throws(() => {}, null);1003	}, {1004		assertion: 'throws',1005		message: 'The second argument to `t.throws()` must be an expectation object or `undefined`',1006		values: [{label: 'Called with:', formatted: /null/}],1007	});1008	t.end();1009});1010test('.throwsAsync() fails if passed null', t => {1011	const asserter = new AssertionsBase();1012	failsWith(t, () => {1013		asserter.throwsAsync(() => {}, null);1014	}, {1015		assertion: 'throwsAsync',1016		message: 'The second argument to `t.throwsAsync()` must be an expectation object or `undefined`',1017		values: [{label: 'Called with:', formatted: /null/}],1018	});1019	t.end();1020});1021test('.notThrows()', gather(t => {1022	// Passes because the function doesn't throw1023	passes(t, () => assertions.notThrows(() => {}), {expectBoolean: false});1024	passes(t, () => assertions.notThrows(() => {}), {expectBoolean: false});1025	// Fails because the function throws.1026	failsWith(t, () => assertions.notThrows(() => {1027		throw new Error('foo');1028	}), {1029		assertion: 'notThrows',1030		message: '',1031		values: [{label: 'Function threw:', formatted: /foo/}],1032	}, {expectBoolean: false});1033	// Fails because the function throws. Asserts that message is used for the1034	// assertion, not to validate the thrown error.1035	failsWith(t, () => assertions.notThrows(() => {1036		throw new Error('foo');1037	}, 'my message'), {1038		assertion: 'notThrows',1039		message: 'my message',1040		values: [{label: 'Function threw:', formatted: /foo/}],1041	}, {expectBoolean: false});1042	failsWith(t, () => assertions.notThrows(() => {}, null), {1043		assertion: 'notThrows',1044		improperUsage: true,1045		message: 'The assertion message must be a string',1046		values: [{1047			label: 'Called with:',1048			formatted: /null/,1049		}],1050	}, {expectBoolean: false});1051}));1052test('.notThrowsAsync()', gather(t => {1053	// Passes because the promise is resolved1054	notThrowsAsyncPasses(t, () => assertions.notThrowsAsync(Promise.resolve()));1055	notThrowsAsyncPasses(t, () => assertions.notThrowsAsync(Promise.resolve()));1056	// Fails because the promise is rejected1057	notThrowsAsyncFails(t, () => assertions.notThrowsAsync(Promise.reject(new Error())), {1058		assertion: 'notThrowsAsync',1059		message: '',1060		values: [{label: 'Promise rejected with:', formatted: /Error/}],1061	});1062	// Passes because the function returned a resolved promise1063	notThrowsAsyncPasses(t, () => assertions.notThrowsAsync(() => Promise.resolve()));1064	// Fails because the function returned a rejected promise1065	notThrowsAsyncFails(t, () => assertions.notThrowsAsync(() => Promise.reject(new Error())), {1066		assertion: 'notThrowsAsync',1067		message: '',1068		values: [{label: 'Returned promise rejected with:', formatted: /Error/}],1069	});1070	// Fails because the function throws synchronously1071	notThrowsAsyncFails(t, () => assertions.notThrowsAsync(() => {1072		throw new Error('sync');1073	}, 'message'), {1074		assertion: 'notThrowsAsync',1075		message: 'message',1076		values: [1077			{label: 'Function threw:', formatted: /Error/},1078		],1079	});1080	// Fails because the function did not return a promise1081	notThrowsAsyncFails(t, () => assertions.notThrowsAsync(() => {}, 'message'), {1082		assertion: 'notThrowsAsync',1083		message: 'message',1084		values: [1085			{label: 'Function did not return a promise. Use `t.notThrows()` instead:', formatted: /undefined/},1086		],1087	});1088	notThrowsAsyncFails(t, () => assertions.notThrowsAsync(Promise.resolve(), null), {1089		assertion: 'notThrowsAsync',1090		improperUsage: true,1091		message: 'The assertion message must be a string',1092		values: [{1093			label: 'Called with:',1094			formatted: /null/,1095		}],1096	});1097}));1098test('.notThrowsAsync() returns undefined for a fulfilled promise', t => assertions.notThrowsAsync(Promise.resolve(Symbol(''))).then(actual => {1099	t.equal(actual, undefined);1100}));1101test('.notThrowsAsync() returns undefined for a fulfilled promise returned by the function', t => assertions.notThrowsAsync(() => Promise.resolve(Symbol(''))).then(actual => {1102	t.equal(actual, undefined);...