Worse-than-linear assert performance for trivial mismatch

Version

v24.14.0

Platform

Linux desktop-home 6.12.77 #1-NixOS SMP PREEMPT_DYNAMIC Fri Mar 13 16:20:49 UTC 2026 x86_64 GNU/Linux

Subsystem

assert

What steps will reproduce the bug?

"use strict";

const assert = require("node:assert");

(async () => {
	let perf1000bytes;
	
	for (let i = 1000; i < 35000; i += 1000) {
		let buffer = Buffer.alloc(i);
		// console.log(i);
		
		let start = Date.now();
		try {
			assert.strictEqual(buffer, [buffer]);
		} catch (_error) {}
		let time = Date.now() - start;

		if (i === 1000) {
			perf1000bytes = time;
			console.log(`${i} bytes: ${time}ms`);
		} else {
			let expected = (i / 1000) * perf1000bytes;
			let worse = (((time / expected) * 100) - expected).toFixed(2);

			console.log(`${i} bytes: ${time}ms (${worse}% worse than linear)`);
		}
	}
})();

Output shows Buffer length, how long it took to make (and fail) the comparison, and how much worse-than-linear it is compared to the 1000-byte case.

How often does it reproduce? Is there a required condition?

Reliably on my system, when comparing a Buffer and an array containing a Buffer (and nothing else). Encountered it organically while writing a test for a project. Not tested with other data structures. Occurs with both strictEqual and deepStrictEqual (especially the former is unexpected).

What is the expected behavior? Why is that the expected behavior?

Should ideally immediately recognize that a Buffer and an array are not the same thing and fail the assertion, or fail upon realizing that the two are not the same length at all, or at worst be linear in its performance (one of the inputs only has a single item after all).

What do you see instead?

1000 bytes: 51ms
2000 bytes: 187ms (81.33% worse than linear)
3000 bytes: 381ms (96.02% worse than linear)
4000 bytes: 662ms (120.51% worse than linear)
5000 bytes: 962ms (122.25% worse than linear)
6000 bytes: 1395ms (149.88% worse than linear)
7000 bytes: 1773ms (139.64% worse than linear)
8000 bytes: 2308ms (157.69% worse than linear)
9000 bytes: 2925ms (178.25% worse than linear)
10000 bytes: 3634ms (202.55% worse than linear)
11000 bytes: 4294ms (204.42% worse than linear)
12000 bytes: 5153ms (229.99% worse than linear)
13000 bytes: 5961ms (236.10% worse than linear)
14000 bytes: 7058ms (274.52% worse than linear)
15000 bytes: 7878ms (264.80% worse than linear)
16000 bytes: 9034ms (291.11% worse than linear)
17000 bytes: 10457ms (339.11% worse than linear)
18000 bytes: 12672ms (462.39% worse than linear)
19000 bytes: 14424ms (519.54% worse than linear)
20000 bytes: 16561ms (603.63% worse than linear)
21000 bytes: 18757ms (680.35% worse than linear)
22000 bytes: 20738ms (726.31% worse than linear)

Additional information

No response