ava 5.3.1 → 6.0.1

package/lib/assert.js

@@ -1,5 +1,6 @@
+import {isNativeError} from 'node:util/types';
+
 import concordance from 'concordance';
-import isError from 'is-error';
 import isPromise from 'is-promise';
 
 import concordanceOptions from './concordance-options.js';
@@ -27,61 +28,55 @@ function formatWithLabel(label, value) {
 	return formatDescriptorWithLabel(label, concordance.describe(value, concordanceOptions));
 }
 
-const hasOwnProperty = (object, prop) => Object.prototype.hasOwnProperty.call(object, prop);
 const noop = () => {};
 const notImplemented = () => {
 	throw new Error('not implemented');
 };
 
 export class AssertionError extends Error {
-	constructor(options) {
-		super(options.message || '');
+	constructor(message = '', {
+		assertion,
+		assertionStack = getAssertionStack(AssertionError),
+		formattedDetails = [],
+		improperUsage = null,
+		cause,
+	} = {}) {
+		super(message, {cause});
 		this.name = 'AssertionError';
 
-		this.assertion = options.assertion;
-		this.fixedSource = options.fixedSource;
-		this.improperUsage = options.improperUsage || false;
-		this.actualStack = options.actualStack;
-		this.operator = options.operator;
-		this.values = options.values || [];
-
-		// Raw expected and actual objects are stored for custom reporters
-		// (such as wallaby.js), that manage worker processes directly and
-		// use the values for custom diff views
-		this.raw = options.raw;
-
-		this.savedError = options.savedError || getErrorWithLongStackTrace();
+		this.assertion = assertion;
+		this.assertionStack = assertionStack;
+		this.improperUsage = improperUsage;
+		this.formattedDetails = formattedDetails;
 	}
 }
 
-export function checkAssertionMessage(assertion, message) {
+export function checkAssertionMessage(message, assertion) {
 	if (message === undefined || typeof message === 'string') {
 		return true;
 	}
 
-	return new AssertionError({
+	return new AssertionError('The assertion message must be a string', {
 		assertion,
-		improperUsage: true,
-		message: 'The assertion message must be a string',
-		values: [formatWithLabel('Called with:', message)],
+		formattedDetails: [formatWithLabel('Called with:', message)],
 	});
 }
 
-function getErrorWithLongStackTrace() {
-	const limitBefore = Error.stackTraceLimit;
+export function getAssertionStack(constructorOpt = getAssertionStack) {
+	const {stackTraceLimit: limitBefore} = Error;
 	Error.stackTraceLimit = Number.POSITIVE_INFINITY;
-	const error = new Error(); // eslint-disable-line unicorn/error-message
+	const temporary = {};
+	Error.captureStackTrace(temporary, constructorOpt);
 	Error.stackTraceLimit = limitBefore;
-	return error;
+	return temporary.stack;
 }
 
 function validateExpectations(assertion, expectations, numberArgs) { // eslint-disable-line complexity
 	if (numberArgs === 1 || expectations === null || expectations === undefined) {
 		if (expectations === null) {
-			throw new AssertionError({
+			throw new AssertionError(`The second argument to \`${assertion}\` must be an expectation object or \`undefined\``, {
 				assertion,
-				message: `The second argument to \`t.${assertion}()\` must be an expectation object or \`undefined\``,
-				values: [formatWithLabel('Called with:', expectations)],
+				formattedDetails: [formatWithLabel('Called with:', expectations)],
 			});
 		}
 
@@ -94,46 +89,48 @@ function validateExpectations(assertion, expectations, numberArgs) { // eslint-d
 		|| Array.isArray(expectations)
 		|| Object.keys(expectations).length === 0
 	) {
-		throw new AssertionError({
+		throw new AssertionError(`The second argument to \`${assertion}\` must be an expectation object, \`null\` or \`undefined\``, {
 			assertion,
-			message: `The second argument to \`t.${assertion}()\` must be an expectation object, \`null\` or \`undefined\``,
-			values: [formatWithLabel('Called with:', expectations)],
+			formattedDetails: [formatWithLabel('Called with:', expectations)],
 		});
 	} else {
-		if (hasOwnProperty(expectations, 'instanceOf') && typeof expectations.instanceOf !== 'function') {
-			throw new AssertionError({
+		if (Object.hasOwn(expectations, 'instanceOf') && typeof expectations.instanceOf !== 'function') {
+			throw new AssertionError(`The \`instanceOf\` property of the second argument to \`${assertion}\` must be a function`, {
 				assertion,
-				message: `The \`instanceOf\` property of the second argument to \`t.${assertion}()\` must be a function`,
-				values: [formatWithLabel('Called with:', expectations)],
+				formattedDetails: [formatWithLabel('Called with:', expectations)],
 			});
 		}
 
 		if (
-			hasOwnProperty(expectations, 'message')
+			Object.hasOwn(expectations, 'message')
 			&& typeof expectations.message !== 'string'
 			&& !(expectations.message instanceof RegExp)
 			&& !(typeof expectations.message === 'function')
 		) {
-			throw new AssertionError({
+			throw new AssertionError(`The \`message\` property of the second argument to \`${assertion}\` must be a string, regular expression or a function`, {
 				assertion,
-				message: `The \`message\` property of the second argument to \`t.${assertion}()\` must be a string, regular expression or a function`,
-				values: [formatWithLabel('Called with:', expectations)],
+				formattedDetails: [formatWithLabel('Called with:', expectations)],
 			});
 		}
 
-		if (hasOwnProperty(expectations, 'name') && typeof expectations.name !== 'string') {
-			throw new AssertionError({
+		if (Object.hasOwn(expectations, 'name') && typeof expectations.name !== 'string') {
+			throw new AssertionError(`The \`name\` property of the second argument to \`${assertion}\` must be a string`, {
 				assertion,
-				message: `The \`name\` property of the second argument to \`t.${assertion}()\` must be a string`,
-				values: [formatWithLabel('Called with:', expectations)],
+				formattedDetails: [formatWithLabel('Called with:', expectations)],
 			});
 		}
 
-		if (hasOwnProperty(expectations, 'code') && typeof expectations.code !== 'string' && typeof expectations.code !== 'number') {
-			throw new AssertionError({
+		if (Object.hasOwn(expectations, 'code') && typeof expectations.code !== 'string' && typeof expectations.code !== 'number') {
+			throw new AssertionError(`The \`code\` property of the second argument to \`${assertion}\` must be a string or number`, {
 				assertion,
-				message: `The \`code\` property of the second argument to \`t.${assertion}()\` must be a string or number`,
-				values: [formatWithLabel('Called with:', expectations)],
+				formattedDetails: [formatWithLabel('Called with:', expectations)],
+			});
+		}
+
+		if (Object.hasOwn(expectations, 'any') && typeof expectations.any !== 'boolean') {
+			throw new AssertionError(`The \`any\` property of the second argument to \`${assertion}\` must be a boolean`, {
+				assertion,
+				formattedDetails: [formatWithLabel('Called with:', expectations)],
 			});
 		}
 
@@ -143,15 +140,15 @@ function validateExpectations(assertion, expectations, numberArgs) { // eslint-d
 				case 'is':
 				case 'message':
 				case 'name':
-				case 'code': {
+				case 'code':
+				case 'any': {
 					continue;
 				}
 
 				default: {
-					throw new AssertionError({
+					throw new AssertionError(`The second argument to \`${assertion}\` contains unexpected properties`, {
 						assertion,
-						message: `The second argument to \`t.${assertion}()\` contains unexpected properties`,
-						values: [formatWithLabel('Called with:', expectations)],
+						formattedDetails: [formatWithLabel('Called with:', expectations)],
 					});
 				}
 			}
@@ -163,25 +160,23 @@ function validateExpectations(assertion, expectations, numberArgs) { // eslint-d
 
 // Note: this function *must* throw exceptions, since it can be used
 // as part of a pending assertion for promises.
-function assertExpectations({assertion, actual, expectations, message, prefix, savedError}) {
-	if (!isError(actual)) {
-		throw new AssertionError({
+function assertExpectations({actual, expectations, message, prefix, assertion, assertionStack}) {
+	const allowThrowAnything = Object.hasOwn(expectations, 'any') && expectations.any;
+	if (!isNativeError(actual) && !allowThrowAnything) {
+		throw new AssertionError(message, {
 			assertion,
-			message,
-			savedError,
-			values: [formatWithLabel(`${prefix} exception that is not an error:`, actual)],
+			assertionStack,
+			cause: actual,
+			formattedDetails: [formatWithLabel(`${prefix} exception that is not an error:`, actual)],
 		});
 	}
 
-	const actualStack = actual.stack;
-
-	if (hasOwnProperty(expectations, 'is') && actual !== expectations.is) {
-		throw new AssertionError({
+	if (Object.hasOwn(expectations, 'is') && actual !== expectations.is) {
+		throw new AssertionError(message, {
 			assertion,
-			message,
-			savedError,
-			actualStack,
-			values: [
+			assertionStack,
+			cause: actual,
+			formattedDetails: [
 				formatWithLabel(`${prefix} unexpected exception:`, actual),
 				formatWithLabel('Expected to be strictly equal to:', expectations.is),
 			],
@@ -189,12 +184,11 @@ function assertExpectations({assertion, actual, expectations, message, prefix, s
 	}
 
 	if (expectations.instanceOf && !(actual instanceof expectations.instanceOf)) {
-		throw new AssertionError({
+		throw new AssertionError(message, {
 			assertion,
-			message,
-			savedError,
-			actualStack,
-			values: [
+			assertionStack,
+			cause: actual,
+			formattedDetails: [
 				formatWithLabel(`${prefix} unexpected exception:`, actual),
 				formatWithLabel('Expected instance of:', expectations.instanceOf),
 			],
@@ -202,12 +196,11 @@ function assertExpectations({assertion, actual, expectations, message, prefix, s
 	}
 
 	if (typeof expectations.name === 'string' && actual.name !== expectations.name) {
-		throw new AssertionError({
+		throw new AssertionError(message, {
 			assertion,
-			message,
-			savedError,
-			actualStack,
-			values: [
+			assertionStack,
+			cause: actual,
+			formattedDetails: [
 				formatWithLabel(`${prefix} unexpected exception:`, actual),
 				formatWithLabel('Expected name to equal:', expectations.name),
 			],
@@ -215,12 +208,11 @@ function assertExpectations({assertion, actual, expectations, message, prefix, s
 	}
 
 	if (typeof expectations.message === 'string' && actual.message !== expectations.message) {
-		throw new AssertionError({
+		throw new AssertionError(message, {
 			assertion,
-			message,
-			savedError,
-			actualStack,
-			values: [
+			assertionStack,
+			cause: actual,
+			formattedDetails: [
 				formatWithLabel(`${prefix} unexpected exception:`, actual),
 				formatWithLabel('Expected message to equal:', expectations.message),
 			],
@@ -228,12 +220,11 @@ function assertExpectations({assertion, actual, expectations, message, prefix, s
 	}
 
 	if (expectations.message instanceof RegExp && !expectations.message.test(actual.message)) {
-		throw new AssertionError({
+		throw new AssertionError(message, {
 			assertion,
-			message,
-			savedError,
-			actualStack,
-			values: [
+			assertionStack,
+			cause: actual,
+			formattedDetails: [
 				formatWithLabel(`${prefix} unexpected exception:`, actual),
 				formatWithLabel('Expected message to match:', expectations.message),
 			],
@@ -241,12 +232,11 @@ function assertExpectations({assertion, actual, expectations, message, prefix, s
 	}
 
 	if (typeof expectations.message === 'function' && expectations.message(actual.message) === false) {
-		throw new AssertionError({
+		throw new AssertionError(message, {
 			assertion,
-			message,
-			savedError,
-			actualStack,
-			values: [
+			assertionStack,
+			cause: actual,
+			formattedDetails: [
 				formatWithLabel(`${prefix} unexpected exception:`, actual),
 				formatWithLabel('Expected message to return true:', expectations.message),
 			],
@@ -254,12 +244,11 @@ function assertExpectations({assertion, actual, expectations, message, prefix, s
 	}
 
 	if (expectations.code !== undefined && actual.code !== expectations.code) {
-		throw new AssertionError({
+		throw new AssertionError(message, {
 			assertion,
-			message,
-			savedError,
-			actualStack,
-			values: [
+			assertionStack,
+			cause: actual,
+			formattedDetails: [
 				formatWithLabel(`${prefix} unexpected exception:`, actual),
 				formatWithLabel('Expected code to equal:', expectations.code),
 			],
@@ -272,6 +261,7 @@ export class Assertions {
 		pass = notImplemented,
 		pending = notImplemented,
 		fail = notImplemented,
+		failPending = notImplemented,
 		skip = notImplemented,
 		compareWithSnapshot = notImplemented,
 		experiments = {},
@@ -282,142 +272,99 @@ export class Assertions {
 			return assertionFn;
 		};
 
-		const checkMessage = (assertion, message) => {
-			const result = checkAssertionMessage(assertion, message);
-			if (result === true) {
-				return true;
+		const assertMessage = (message, assertion) => {
+			const result = checkAssertionMessage(message, assertion);
+			if (result !== true) {
+				throw fail(result);
 			}
-
-			fail(result);
-			return false;
 		};
 
-		this.pass = withSkip(() => {
-			pass();
-			return true;
-		});
+		this.pass = withSkip(() => pass());
 
 		this.fail = withSkip(message => {
-			if (!checkMessage('fail', message)) {
-				return false;
-			}
+			assertMessage(message, 't.fail()');
 
-			fail(new AssertionError({
-				assertion: 'fail',
-				message: message || 'Test failed via `t.fail()`',
+			throw fail(new AssertionError(message ?? 'Test failed via `t.fail()`', {
+				assertion: 't.fail()',
 			}));
-
-			return false;
 		});
 
 		this.is = withSkip((actual, expected, message) => {
-			if (!checkMessage('is', message)) {
-				return false;
-			}
+			assertMessage(message, 't.is()');
 
 			if (Object.is(actual, expected)) {
-				pass();
-				return true;
+				return pass();
 			}
 
 			const result = concordance.compare(actual, expected, concordanceOptions);
-			const actualDescriptor = result.actual || concordance.describe(actual, concordanceOptions);
-			const expectedDescriptor = result.expected || concordance.describe(expected, concordanceOptions);
+			const actualDescriptor = result.actual ?? concordance.describe(actual, concordanceOptions);
+			const expectedDescriptor = result.expected ?? concordance.describe(expected, concordanceOptions);
 
 			if (result.pass) {
-				fail(new AssertionError({
-					assertion: 'is',
-					message,
-					raw: {actual, expected},
-					values: [formatDescriptorWithLabel('Values are deeply equal to each other, but they are not the same:', actualDescriptor)],
+				throw fail(new AssertionError(message, {
+					assertion: 't.is()',
+					formattedDetails: [formatDescriptorWithLabel('Values are deeply equal to each other, but they are not the same:', actualDescriptor)],
 				}));
 			} else {
-				fail(new AssertionError({
-					assertion: 'is',
-					message,
-					raw: {actual, expected},
-					values: [formatDescriptorDiff(actualDescriptor, expectedDescriptor)],
+				throw fail(new AssertionError(message, {
+					assertion: 't.is()',
+					formattedDetails: [formatDescriptorDiff(actualDescriptor, expectedDescriptor)],
 				}));
 			}
-
-			return false;
 		});
 
 		this.not = withSkip((actual, expected, message) => {
-			if (!checkMessage('not', message)) {
-				return false;
-			}
+			assertMessage(message, 't.not()');
 
 			if (Object.is(actual, expected)) {
-				fail(new AssertionError({
-					assertion: 'not',
-					message,
-					raw: {actual, expected},
-					values: [formatWithLabel('Value is the same as:', actual)],
+				throw fail(new AssertionError(message, {
+					assertion: 't.not()',
+					formattedDetails: [formatWithLabel('Value is the same as:', actual)],
 				}));
-				return false;
 			}
 
-			pass();
-			return true;
+			return pass();
 		});
 
 		this.deepEqual = withSkip((actual, expected, message) => {
-			if (!checkMessage('deepEqual', message)) {
-				return false;
-			}
+			assertMessage(message, 't.deepEqual()');
 
 			const result = concordance.compare(actual, expected, concordanceOptions);
 			if (result.pass) {
-				pass();
-				return true;
+				return pass();
 			}
 
-			const actualDescriptor = result.actual || concordance.describe(actual, concordanceOptions);
-			const expectedDescriptor = result.expected || concordance.describe(expected, concordanceOptions);
-			fail(new AssertionError({
-				assertion: 'deepEqual',
-				message,
-				raw: {actual, expected},
-				values: [formatDescriptorDiff(actualDescriptor, expectedDescriptor)],
+			const actualDescriptor = result.actual ?? concordance.describe(actual, concordanceOptions);
+			const expectedDescriptor = result.expected ?? concordance.describe(expected, concordanceOptions);
+			throw fail(new AssertionError(message, {
+				assertion: 't.deepEqual()',
+				formattedDetails: [formatDescriptorDiff(actualDescriptor, expectedDescriptor)],
 			}));
-			return false;
 		});
 
 		this.notDeepEqual = withSkip((actual, expected, message) => {
-			if (!checkMessage('notDeepEqual', message)) {
-				return false;
-			}
+			assertMessage(message, 't.notDeepEqual()');
 
 			const result = concordance.compare(actual, expected, concordanceOptions);
 			if (result.pass) {
-				const actualDescriptor = result.actual || concordance.describe(actual, concordanceOptions);
-				fail(new AssertionError({
-					assertion: 'notDeepEqual',
-					message,
-					raw: {actual, expected},
-					values: [formatDescriptorWithLabel('Value is deeply equal:', actualDescriptor)],
+				const actualDescriptor = result.actual ?? concordance.describe(actual, concordanceOptions);
+				throw fail(new AssertionError(message, {
+					assertion: 't.notDeepEqual()',
+					formattedDetails: [formatDescriptorWithLabel('Value is deeply equal:', actualDescriptor)],
 				}));
-				return false;
 			}
 
-			pass();
-			return true;
+			return pass();
 		});
 
 		this.like = withSkip((actual, selector, message) => {
-			if (!checkMessage('like', message)) {
-				return false;
-			}
+			assertMessage(message, 't.like()');
 
 			if (!isLikeSelector(selector)) {
-				fail(new AssertionError({
-					assertion: 'like',
-					improperUsage: true,
-					message: '`t.like()` selector must be a non-empty object',
-					values: [formatWithLabel('Called with:', selector)],
+				throw fail(new AssertionError('`t.like()` selector must be a non-empty object', {
+					assertion: 't.like()',
+					formattedDetails: [formatWithLabel('Called with:', selector)],
 				}));
-				return false;
 			}
 
 			let comparable;
@@ -425,13 +372,10 @@ export class Assertions {
 				comparable = selectComparable(actual, selector);
 			} catch (error) {
 				if (error === CIRCULAR_SELECTOR) {
-					fail(new AssertionError({
-						assertion: 'like',
-						improperUsage: true,
-						message: '`t.like()` selector must not contain circular references',
-						values: [formatWithLabel('Called with:', selector)],
+					throw fail(new AssertionError('`t.like()` selector must not contain circular references', {
+						assertion: 't.like()',
+						formattedDetails: [formatWithLabel('Called with:', selector)],
 					}));
-					return false;
 				}
 
 				throw error;
@@ -439,19 +383,15 @@ export class Assertions {
 
 			const result = concordance.compare(comparable, selector, concordanceOptions);
 			if (result.pass) {
-				pass();
-				return true;
+				return pass();
 			}
 
-			const actualDescriptor = result.actual || concordance.describe(comparable, concordanceOptions);
-			const expectedDescriptor = result.expected || concordance.describe(selector, concordanceOptions);
-			fail(new AssertionError({
-				assertion: 'like',
-				message,
-				values: [formatDescriptorDiff(actualDescriptor, expectedDescriptor)],
+			const actualDescriptor = result.actual ?? concordance.describe(comparable, concordanceOptions);
+			const expectedDescriptor = result.expected ?? concordance.describe(selector, concordanceOptions);
+			throw fail(new AssertionError(message, {
+				assertion: 't.like()',
+				formattedDetails: [formatDescriptorDiff(actualDescriptor, expectedDescriptor)],
 			}));
-
-			return false;
 		});
 
 		this.throws = withSkip((...args) => {
@@ -460,25 +400,20 @@ export class Assertions {
 			// to the function.
 			let [fn, expectations, message] = args;
 
-			if (!checkMessage('throws', message)) {
-				return;
-			}
+			assertMessage(message, 't.throws()');
 
 			if (typeof fn !== 'function') {
-				fail(new AssertionError({
-					assertion: 'throws',
-					improperUsage: true,
-					message: '`t.throws()` must be called with a function',
-					values: [formatWithLabel('Called with:', fn)],
+				throw fail(new AssertionError('`t.throws()` must be called with a function', {
+					assertion: 't.throws()',
+					improperUsage: {assertion: 'throws'},
+					formattedDetails: [formatWithLabel('Called with:', fn)],
 				}));
-				return;
 			}
 
 			try {
-				expectations = validateExpectations('throws', expectations, args.length, experiments);
+				expectations = validateExpectations('t.throws()', expectations, args.length, experiments);
 			} catch (error) {
-				fail(error);
-				return;
+				throw fail(error);
 			}
 
 			let retval;
@@ -488,29 +423,25 @@ export class Assertions {
 				if (isPromise(retval)) {
 					// Here isPromise() checks if something is "promise like". Cast to an actual promise.
 					Promise.resolve(retval).catch(noop);
-					fail(new AssertionError({
-						assertion: 'throws',
-						message,
-						values: [formatWithLabel('Function returned a promise. Use `t.throwsAsync()` instead:', retval)],
+					throw fail(new AssertionError(message, {
+						assertion: 't.throws()',
+						formattedDetails: [formatWithLabel('Function returned a promise. Use `t.throwsAsync()` instead:', retval)],
 					}));
-					return;
 				}
 			} catch (error) {
 				actual = error;
 			}
 
 			if (!actual) {
-				fail(new AssertionError({
-					assertion: 'throws',
-					message,
-					values: [formatWithLabel('Function returned:', retval)],
+				throw fail(new AssertionError(message, {
+					assertion: 't.throws()',
+					formattedDetails: [formatWithLabel('Function returned:', retval)],
 				}));
-				return;
 			}
 
 			try {
 				assertExpectations({
-					assertion: 'throws',
+					assertion: 't.throws()',
 					actual,
 					expectations,
 					message,
@@ -519,63 +450,62 @@ export class Assertions {
 				pass();
 				return actual;
 			} catch (error) {
-				fail(error);
+				throw fail(error);
 			}
 		});
 
 		this.throwsAsync = withSkip(async (...args) => {
 			let [thrower, expectations, message] = args;
 
-			if (!checkMessage('throwsAsync', message)) {
-				return;
+			try {
+				assertMessage(message, 't.throwsAsync()');
+			} catch (error) {
+				Promise.resolve(thrower).catch(noop);
+				throw error;
 			}
 
 			if (typeof thrower !== 'function' && !isPromise(thrower)) {
-				fail(new AssertionError({
-					assertion: 'throwsAsync',
-					improperUsage: true,
-					message: '`t.throwsAsync()` must be called with a function or promise',
-					values: [formatWithLabel('Called with:', thrower)],
+				throw fail(new AssertionError('`t.throwsAsync()` must be called with a function or promise', {
+					assertion: 't.throwsAsync()',
+					formattedDetails: [formatWithLabel('Called with:', thrower)],
 				}));
-				return;
 			}
 
 			try {
-				expectations = validateExpectations('throwsAsync', expectations, args.length, experiments);
+				expectations = validateExpectations('t.throwsAsync()', expectations, args.length, experiments);
 			} catch (error) {
-				fail(error);
-				return;
+				Promise.resolve(thrower).catch(noop);
+				throw fail(error);
 			}
 
 			const handlePromise = async (promise, wasReturned) => {
-				// Create an error object to record the stack before it gets lost in the promise chain.
-				const savedError = getErrorWithLongStackTrace();
+				// Record the stack before it gets lost in the promise chain.
+				const assertionStack = getAssertionStack();
 				// Handle "promise like" objects by casting to a real Promise.
 				const intermediate = Promise.resolve(promise).then(value => {
-					throw new AssertionError({
-						assertion: 'throwsAsync',
-						message,
-						savedError,
-						values: [formatWithLabel(`${wasReturned ? 'Returned promise' : 'Promise'} resolved with:`, value)],
-					});
+					throw failPending(new AssertionError(message, {
+						assertion: 't.throwsAsync()',
+						assertionStack,
+						formattedDetails: [formatWithLabel(`${wasReturned ? 'Returned promise' : 'Promise'} resolved with:`, value)],
+					}));
 				}, error => {
-					assertExpectations({
-						assertion: 'throwsAsync',
-						actual: error,
-						expectations,
-						message,
-						prefix: `${wasReturned ? 'Returned promise' : 'Promise'} rejected with`,
-						savedError,
-					});
-					return error;
+					try {
+						assertExpectations({
+							assertion: 't.throwsAsync()',
+							actual: error,
+							expectations,
+							message,
+							prefix: `${wasReturned ? 'Returned promise' : 'Promise'} rejected with`,
+							assertionStack,
+						});
+						return error;
+					} catch (error_) {
+						throw failPending(error_);
+					}
 				});
 
 				pending(intermediate);
-				try {
-					return await intermediate;
-				} catch {
-					// Don't reject the returned promise, even if the assertion fails.
-				}
+				return intermediate;
 			};
 
 			if (isPromise(thrower)) {
@@ -591,90 +521,77 @@ export class Assertions {
 			}
 
 			if (actual) {
-				fail(new AssertionError({
-					assertion: 'throwsAsync',
-					message,
-					actualStack: actual.stack,
-					values: [formatWithLabel('Function threw synchronously. Use `t.throws()` instead:', actual)],
+				throw fail(new AssertionError(message, {
+					assertion: 't.throwsAsync()',
+					cause: actual,
+					formattedDetails: [formatWithLabel('Function threw synchronously. Use `t.throws()` instead:', actual)],
 				}));
-				return;
 			}
 
 			if (isPromise(retval)) {
 				return handlePromise(retval, true);
 			}
 
-			fail(new AssertionError({
-				assertion: 'throwsAsync',
-				message,
-				values: [formatWithLabel('Function returned:', retval)],
+			throw fail(new AssertionError(message, {
+				assertion: 't.throwsAsync()',
+				formattedDetails: [formatWithLabel('Function returned:', retval)],
 			}));
 		});
 
 		this.notThrows = withSkip((fn, message) => {
-			if (!checkMessage('notThrows', message)) {
-				return;
-			}
+			assertMessage(message, 't.notThrows()');
 
 			if (typeof fn !== 'function') {
-				fail(new AssertionError({
-					assertion: 'notThrows',
-					improperUsage: true,
-					message: '`t.notThrows()` must be called with a function',
-					values: [formatWithLabel('Called with:', fn)],
+				throw fail(new AssertionError('`t.notThrows()` must be called with a function', {
+					assertion: 't.notThrows()',
+					improperUsage: {assertion: 'notThrows'},
+					formattedDetails: [formatWithLabel('Called with:', fn)],
 				}));
-				return;
 			}
 
 			try {
 				fn();
 			} catch (error) {
-				fail(new AssertionError({
-					assertion: 'notThrows',
-					message,
-					actualStack: error.stack,
-					values: [formatWithLabel('Function threw:', error)],
+				throw fail(new AssertionError(message, {
+					assertion: 't.notThrows()',
+					cause: error,
+					formattedDetails: [formatWithLabel('Function threw:', error)],
 				}));
-				return;
 			}
 
-			pass();
+			return pass();
 		});
 
-		this.notThrowsAsync = withSkip((nonThrower, message) => {
-			if (!checkMessage('notThrowsAsync', message)) {
-				return Promise.resolve();
+		this.notThrowsAsync = withSkip(async (nonThrower, message) => {
+			try {
+				assertMessage(message, 't.notThrowsAsync()');
+			} catch (error) {
+				Promise.resolve(nonThrower).catch(noop);
+				throw error;
 			}
 
 			if (typeof nonThrower !== 'function' && !isPromise(nonThrower)) {
-				fail(new AssertionError({
-					assertion: 'notThrowsAsync',
-					improperUsage: true,
-					message: '`t.notThrowsAsync()` must be called with a function or promise',
-					values: [formatWithLabel('Called with:', nonThrower)],
+				throw fail(new AssertionError('`t.notThrowsAsync()` must be called with a function or promise', {
+					assertion: 't.notThrowsAsync()',
+					formattedDetails: [formatWithLabel('Called with:', nonThrower)],
 				}));
-				return Promise.resolve();
 			}
 
 			const handlePromise = async (promise, wasReturned) => {
 				// Create an error object to record the stack before it gets lost in the promise chain.
-				const savedError = getErrorWithLongStackTrace();
+				const assertionStack = getAssertionStack();
 				// Handle "promise like" objects by casting to a real Promise.
 				const intermediate = Promise.resolve(promise).then(noop, error => {
-					throw new AssertionError({
-						assertion: 'notThrowsAsync',
-						message,
-						savedError,
-						values: [formatWithLabel(`${wasReturned ? 'Returned promise' : 'Promise'} rejected with:`, error)],
-					});
+					throw failPending(new AssertionError(message, {
+						assertion: 't.notThrowsAsync()',
+						assertionStack,
+						formattedDetails: [formatWithLabel(`${wasReturned ? 'Returned promise' : 'Promise'} rejected with:`, error)],
+					}));
 				});
 				pending(intermediate);
 
-				try {
-					return await intermediate;
-				} catch {
-					// Don't reject the returned promise, even if the assertion fails.
-				}
+				await intermediate;
+				return true;
 			};
 
 			if (isPromise(nonThrower)) {
@@ -685,22 +602,18 @@ export class Assertions {
 			try {
 				retval = nonThrower();
 			} catch (error) {
-				fail(new AssertionError({
-					assertion: 'notThrowsAsync',
-					message,
-					actualStack: error.stack,
-					values: [formatWithLabel('Function threw:', error)],
+				throw fail(new AssertionError(message, {
+					assertion: 't.notThrowsAsync()',
+					cause: error,
+					formattedDetails: [formatWithLabel('Function threw:', error)],
 				}));
-				return Promise.resolve();
 			}
 
 			if (!isPromise(retval)) {
-				fail(new AssertionError({
-					assertion: 'notThrowsAsync',
-					message,
-					values: [formatWithLabel('Function did not return a promise. Use `t.notThrows()` instead:', retval)],
+				throw fail(new AssertionError(message, {
+					assertion: 't.notThrowsAsync()',
+					formattedDetails: [formatWithLabel('Function did not return a promise. Use `t.notThrows()` instead:', retval)],
 				}));
-				return Promise.resolve();
 			}
 
 			return handlePromise(retval, true);
@@ -708,36 +621,25 @@ export class Assertions {
 
 		this.snapshot = withSkip((expected, message) => {
 			if (disableSnapshots) {
-				fail(new AssertionError({
-					assertion: 'snapshot',
-					message: '`t.snapshot()` can only be used in tests',
-					improperUsage: true,
+				throw fail(new AssertionError('`t.snapshot()` can only be used in tests', {
+					assertion: 't.snapshot()',
 				}));
-				return false;
 			}
 
-			if (message && message.id !== undefined) {
-				fail(new AssertionError({
-					assertion: 'snapshot',
-					message: 'AVA 4 no longer supports snapshot IDs',
-					improperUsage: true,
-					values: [formatWithLabel('Called with id:', message.id)],
+			if (message?.id !== undefined) {
+				throw fail(new AssertionError('Since AVA 4, snapshot IDs are no longer supported', {
+					assertion: 't.snapshot()',
+					formattedDetails: [formatWithLabel('Called with id:', message.id)],
 				}));
-				return false;
 			}
 
-			if (!checkMessage('snapshot', message)) {
-				return false;
-			}
+			assertMessage(message, 't.snapshot()');
 
 			if (message === '') {
-				fail(new AssertionError({
-					assertion: 'snapshot',
-					improperUsage: true,
-					message: 'The snapshot assertion message must be a non-empty string',
-					values: [formatWithLabel('Called with:', message)],
+				throw fail(new AssertionError('The snapshot assertion message must be a non-empty string', {
+					assertion: 't.snapshot()',
+					formattedDetails: [formatWithLabel('Called with:', message)],
 				}));
-				return false;
 			}
 
 			let result;
@@ -748,215 +650,158 @@ export class Assertions {
 					throw error;
 				}
 
-				const improperUsage = {name: error.name, snapPath: error.snapPath};
+				const improperUsage = {assertion: 'snapshot', name: error.name, snapPath: error.snapPath};
 				if (error instanceof VersionMismatchError) {
 					improperUsage.snapVersion = error.snapVersion;
 					improperUsage.expectedVersion = error.expectedVersion;
 				}
 
-				fail(new AssertionError({
-					assertion: 'snapshot',
-					message: message || 'Could not compare snapshot',
+				throw fail(new AssertionError(message ?? 'Could not compare snapshot', {
+					asssertion: 't.snapshot()',
 					improperUsage,
 				}));
-				return false;
 			}
 
 			if (result.pass) {
-				pass();
-				return true;
+				return pass();
 			}
 
 			if (result.actual) {
-				fail(new AssertionError({
-					assertion: 'snapshot',
-					message: message || 'Did not match snapshot',
-					values: [formatDescriptorDiff(result.actual, result.expected, {invert: true})],
+				throw fail(new AssertionError(message ?? 'Did not match snapshot', {
+					assertion: 't.snapshot()',
+					formattedDetails: [formatDescriptorDiff(result.actual, result.expected, {invert: true})],
 				}));
 			} else {
 				// This can only occur in CI environments.
-				fail(new AssertionError({
-					assertion: 'snapshot',
-					message: message || 'No snapshot available — new snapshots are not created in CI environments',
+				throw fail(new AssertionError(message ?? 'No snapshot available — new snapshots are not created in CI environments', {
+					assertion: 't.snapshot()',
 				}));
 			}
-
-			return false;
 		});
 
 		this.truthy = withSkip((actual, message) => {
-			if (!checkMessage('truthy', message)) {
-				return false;
-			}
+			assertMessage(message, 't.truthy()');
 
 			if (actual) {
-				pass();
-				return true;
+				return pass();
 			}
 
-			fail(new AssertionError({
-				assertion: 'truthy',
-				message,
-				operator: '!!',
-				values: [formatWithLabel('Value is not truthy:', actual)],
+			throw fail(new AssertionError(message, {
+				assertion: 't.truthy()',
+				formattedDetails: [formatWithLabel('Value is not truthy:', actual)],
 			}));
-			return false;
 		});
 
 		this.falsy = withSkip((actual, message) => {
-			if (!checkMessage('falsy', message)) {
-				return false;
-			}
+			assertMessage(message, 't.falsy()');
 
 			if (actual) {
-				fail(new AssertionError({
-					assertion: 'falsy',
-					message,
-					operator: '!',
-					values: [formatWithLabel('Value is not falsy:', actual)],
+				throw fail(new AssertionError(message, {
+					assertion: 't.falsy()',
+					formattedDetails: [formatWithLabel('Value is not falsy:', actual)],
 				}));
-				return false;
 			}
 
-			pass();
-			return true;
+			return pass();
 		});
 
 		this.true = withSkip((actual, message) => {
-			if (!checkMessage('true', message)) {
-				return false;
-			}
+			assertMessage(message, 't.true()');
 
 			if (actual === true) {
-				pass();
-				return true;
+				return pass();
 			}
 
-			fail(new AssertionError({
-				assertion: 'true',
-				message,
-				values: [formatWithLabel('Value is not `true`:', actual)],
+			throw fail(new AssertionError(message, {
+				assertion: 't.true()',
+				formattedDetails: [formatWithLabel('Value is not `true`:', actual)],
 			}));
-			return false;
 		});
 
 		this.false = withSkip((actual, message) => {
-			if (!checkMessage('false', message)) {
-				return false;
-			}
+			assertMessage(message, 't.false()');
 
 			if (actual === false) {
-				pass();
-				return true;
+				return pass();
 			}
 
-			fail(new AssertionError({
-				assertion: 'false',
-				message,
-				values: [formatWithLabel('Value is not `false`:', actual)],
+			throw fail(new AssertionError(message, {
+				assertion: 't.false()',
+				formattedDetails: [formatWithLabel('Value is not `false`:', actual)],
 			}));
-			return false;
 		});
 
 		this.regex = withSkip((string, regex, message) => {
-			if (!checkMessage('regex', message)) {
-				return false;
-			}
+			assertMessage(message, 't.regex()');
 
 			if (typeof string !== 'string') {
-				fail(new AssertionError({
-					assertion: 'regex',
-					improperUsage: true,
-					message: '`t.regex()` must be called with a string',
-					values: [formatWithLabel('Called with:', string)],
+				throw fail(new AssertionError('`t.regex()` must be called with a string', {
+					assertion: 't.regex()',
+					formattedDetails: [formatWithLabel('Called with:', string)],
 				}));
-				return false;
 			}
 
 			if (!(regex instanceof RegExp)) {
-				fail(new AssertionError({
-					assertion: 'regex',
-					improperUsage: true,
-					message: '`t.regex()` must be called with a regular expression',
-					values: [formatWithLabel('Called with:', regex)],
+				throw fail(new AssertionError('`t.regex()` must be called with a regular expression', {
+					assertion: 't.regex()',
+					formattedDetails: [formatWithLabel('Called with:', regex)],
 				}));
-				return false;
 			}
 
 			if (!regex.test(string)) {
-				fail(new AssertionError({
-					assertion: 'regex',
-					message,
-					values: [
+				throw fail(new AssertionError(message, {
+					assertion: 't.regex()',
+					formattedDetails: [
 						formatWithLabel('Value must match expression:', string),
 						formatWithLabel('Regular expression:', regex),
 					],
 				}));
-				return false;
 			}
 
-			pass();
-			return true;
+			return pass();
 		});
 
 		this.notRegex = withSkip((string, regex, message) => {
-			if (!checkMessage('notRegex', message)) {
-				return false;
-			}
+			assertMessage(message, 't.notRegex()');
 
 			if (typeof string !== 'string') {
-				fail(new AssertionError({
-					assertion: 'notRegex',
-					improperUsage: true,
-					message: '`t.notRegex()` must be called with a string',
-					values: [formatWithLabel('Called with:', string)],
+				throw fail(new AssertionError('`t.notRegex()` must be called with a string', {
+					assertion: 't.notRegex()',
+					formattedDetails: [formatWithLabel('Called with:', string)],
 				}));
-				return false;
 			}
 
 			if (!(regex instanceof RegExp)) {
-				fail(new AssertionError({
-					assertion: 'notRegex',
-					improperUsage: true,
-					message: '`t.notRegex()` must be called with a regular expression',
-					values: [formatWithLabel('Called with:', regex)],
+				throw fail(new AssertionError('`t.notRegex()` must be called with a regular expression', {
+					assertion: 't.notRegex()',
+					formattedDetails: [formatWithLabel('Called with:', regex)],
 				}));
-				return false;
 			}
 
 			if (regex.test(string)) {
-				fail(new AssertionError({
-					assertion: 'notRegex',
-					message,
-					values: [
+				throw fail(new AssertionError(message, {
+					assertion: 't.notRegex()',
+					formattedDetails: [
 						formatWithLabel('Value must not match expression:', string),
 						formatWithLabel('Regular expression:', regex),
 					],
 				}));
-				return false;
 			}
 
-			pass();
-			return true;
+			return pass();
 		});
 
 		this.assert = withSkip((actual, message) => {
-			if (!checkMessage('assert', message)) {
-				return false;
-			}
+			assertMessage(message, 't.assert()');
 
 			if (!actual) {
-				fail(new AssertionError({
-					assertion: 'assert',
-					message,
-					operator: '!!',
-					values: [formatWithLabel('Value is not truthy:', actual)],
+				throw fail(new AssertionError(message, {
+					assertion: 't.assert()',
+					formattedDetails: [formatWithLabel('Value is not truthy:', actual)],
 				}));
-				return false;
 			}
 
-			pass();
-			return true;
+			return pass();
 		});
 	}
 }