+147

tests/bench_includes_breakdown.cjs

reviewed

··· 1 1 + function runBench(label, iterations, fn, options) { 2 2 + const warmup = options && options.warmup ? options.warmup : 5; 3 3 + const samples = options && options.samples ? options.samples : 10; 4 4 + 5 5 + for (let i = 0; i < warmup; i++) fn(); 6 6 + 7 7 + let min = Infinity; 8 8 + let max = -Infinity; 9 9 + let total = 0; 10 10 + let last = 0; 11 11 + 12 12 + for (let i = 0; i < samples; i++) { 13 13 + const start = performance.now(); 14 14 + last = fn(); 15 15 + const elapsed = performance.now() - start; 16 16 + if (elapsed < min) min = elapsed; 17 17 + if (elapsed > max) max = elapsed; 18 18 + total += elapsed; 19 19 + } 20 20 + 21 21 + const mean = total / samples; 22 22 + const opsPerMs = iterations / mean; 23 23 + 24 24 + console.log(label); 25 25 + console.log(` iterations: ${iterations}`); 26 26 + console.log(` result: ${last}`); 27 27 + console.log(` mean: ${mean.toFixed(3)} ms`); 28 28 + console.log(` min: ${min.toFixed(3)} ms`); 29 29 + console.log(` max: ${max.toFixed(3)} ms`); 30 30 + console.log(` ops/ms: ${opsPerMs.toFixed(1)}`); 31 31 + } 32 32 + 33 33 + const dense = []; 34 34 + for (let i = 0; i < 1024; i++) dense.push(i); 35 35 + 36 36 + const sparse = Array(1024); 37 37 + 38 38 + const genericOwn = { 39 39 + get length() { 40 40 + return 1024; 41 41 + }, 42 42 + get 1023() { 43 43 + return 1; 44 44 + } 45 45 + }; 46 46 + 47 47 + const genericProtoBase = { 1023: 1 }; 48 48 + const genericProto = Object.create(genericProtoBase); 49 49 + Object.defineProperty(genericProto, "length", { 50 50 + configurable: true, 51 51 + enumerable: true, 52 52 + get() { 53 53 + return 1024; 54 54 + } 55 55 + }); 56 56 + 57 57 + const proxy = new Proxy( 58 58 + { length: 4, 0: NaN, 1: 0, 2: NaN, 3: 1 }, 59 59 + { 60 60 + get(target, key) { 61 61 + return target[key]; 62 62 + } 63 63 + } 64 64 + ); 65 65 + 66 66 + const typed = new Uint32Array(1024); 67 67 + typed[1023] = 1; 68 68 + 69 69 + runBench("dense hit tail", 20000, () => { 70 70 + let hits = 0; 71 71 + for (let r = 0; r < 20000; r++) { 72 72 + if (dense.includes(1023)) hits++; 73 73 + } 74 74 + return hits; 75 75 + }); 76 76 + 77 77 + runBench("dense miss", 20000, () => { 78 78 + let hits = 0; 79 79 + for (let r = 0; r < 20000; r++) { 80 80 + if (dense.includes(-1)) hits++; 81 81 + } 82 82 + return hits; 83 83 + }); 84 84 + 85 85 + runBench("dense hit negative fromIndex", 20000, () => { 86 86 + let hits = 0; 87 87 + for (let r = 0; r < 20000; r++) { 88 88 + if (dense.includes(1023, -1)) hits++; 89 89 + } 90 90 + return hits; 91 91 + }); 92 92 + 93 93 + runBench("sparse includes(undefined)", 50000, () => { 94 94 + let hits = 0; 95 95 + for (let r = 0; r < 50000; r++) { 96 96 + if (sparse.includes(undefined)) hits++; 97 97 + } 98 98 + return hits; 99 99 + }); 100 100 + 101 101 + runBench("sparse miss non-undefined", 50000, () => { 102 102 + let hits = 0; 103 103 + for (let r = 0; r < 50000; r++) { 104 104 + if (sparse.includes(1)) hits++; 105 105 + } 106 106 + return hits; 107 107 + }); 108 108 + 109 109 + runBench("generic own getter", 20000, () => { 110 110 + let hits = 0; 111 111 + for (let r = 0; r < 20000; r++) { 112 112 + if ([].includes.call(genericOwn, 1, 1023)) hits++; 113 113 + } 114 114 + return hits; 115 115 + }); 116 116 + 117 117 + runBench("generic inherited value", 20000, () => { 118 118 + let hits = 0; 119 119 + for (let r = 0; r < 20000; r++) { 120 120 + if ([].includes.call(genericProto, 1, 1023)) hits++; 121 121 + } 122 122 + return hits; 123 123 + }); 124 124 + 125 125 + runBench("proxy NaN fromIndex", 20000, () => { 126 126 + let hits = 0; 127 127 + for (let r = 0; r < 20000; r++) { 128 128 + if (Array.prototype.includes.call(proxy, NaN, 1)) hits++; 129 129 + } 130 130 + return hits; 131 131 + }); 132 132 + 133 133 + runBench("typedarray hit", 50000, () => { 134 134 + let hits = 0; 135 135 + for (let r = 0; r < 50000; r++) { 136 136 + if (typed.includes(1)) hits++; 137 137 + } 138 138 + return hits; 139 139 + }); 140 140 + 141 141 + runBench("typedarray miss", 50000, () => { 142 142 + let hits = 0; 143 143 + for (let r = 0; r < 50000; r++) { 144 144 + if (typed.includes(2)) hits++; 145 145 + } 146 146 + return hits; 147 147 + });

+86

tests/test_array_includes_regression_big.cjs

reviewed

··· 1 1 + const assert = require("node:assert"); 2 2 + 3 3 + function assertArrayIncludesRegressionSurface() { 4 4 + assert.strictEqual([1, 2, 3].includes(2), true); 5 5 + assert.strictEqual([1, 2, 3].includes(4), false); 6 6 + assert.strictEqual([1, 2, 3].includes(1, 1), false); 7 7 + assert.strictEqual([NaN].includes(NaN), true); 8 8 + assert.strictEqual([1, 2, 3].includes(3, -1), true); 9 9 + assert.strictEqual([1, 2, 3].includes(1, -1), false); 10 10 + 11 11 + assert.strictEqual([,].includes(undefined), true); 12 12 + assert.strictEqual(Array(4).includes(undefined), true); 13 13 + assert.strictEqual(Array(4).includes(1), false); 14 14 + 15 15 + const holey = []; 16 16 + holey[3] = "tail"; 17 17 + assert.strictEqual(holey.includes(undefined), true); 18 18 + assert.strictEqual(holey.includes("tail"), true); 19 19 + assert.strictEqual(holey.includes("tail", 4), false); 20 20 + 21 21 + let steps = 0; 22 22 + const generic = { 23 23 + get length() { 24 24 + steps += 1; 25 25 + return 6; 26 26 + }, 27 27 + get 2() { 28 28 + steps += 10; 29 29 + return "match"; 30 30 + }, 31 31 + get 4() { 32 32 + steps += 100; 33 33 + return "late"; 34 34 + } 35 35 + }; 36 36 + assert.strictEqual([].includes.call(generic, "match", 1), true); 37 37 + assert.strictEqual(steps, 11); 38 38 + 39 39 + const proto = { 3: "from-proto" }; 40 40 + const inherited = Object.create(proto); 41 41 + Object.defineProperty(inherited, "length", { 42 42 + configurable: true, 43 43 + enumerable: true, 44 44 + get() { 45 45 + return 5; 46 46 + } 47 47 + }); 48 48 + assert.strictEqual([].includes.call(inherited, "from-proto"), true); 49 49 + assert.strictEqual([].includes.call(inherited, undefined), true); 50 50 + 51 51 + const proxyLog = []; 52 52 + const proxy = new Proxy( 53 53 + { length: 4, 0: NaN, 1: "", 2: NaN, 3: "" }, 54 54 + { 55 55 + get(target, key) { 56 56 + proxyLog.push(String(key)); 57 57 + return target[key]; 58 58 + } 59 59 + } 60 60 + ); 61 61 + assert.strictEqual(Array.prototype.includes.call(proxy, NaN, 1), true); 62 62 + assert.deepStrictEqual(proxyLog, ["length", "1", "2"]); 63 63 + 64 64 + [ 65 65 + Int8Array, 66 66 + Uint8Array, 67 67 + Uint8ClampedArray, 68 68 + Int16Array, 69 69 + Uint16Array, 70 70 + Int32Array, 71 71 + Uint32Array, 72 72 + Float32Array, 73 73 + Float64Array 74 74 + ].forEach((TypedArray) => { 75 75 + const view = new TypedArray([1, 2, 3]); 76 76 + assert.strictEqual(view.includes(1), true); 77 77 + assert.strictEqual(view.includes(4), false); 78 78 + assert.strictEqual(view.includes(1, 1), false); 79 79 + }); 80 80 + 81 81 + const floatView = new Float64Array([1, NaN, 3]); 82 82 + assert.strictEqual(floatView.includes(NaN), true); 83 83 + } 84 84 + 85 85 + assertArrayIncludesRegressionSurface(); 86 86 + console.log("array includes regression surface passes");