| 'use strict'; |
| |
| const common = require('../common'); |
| const vm = require('node:vm'); |
| const assert = require('node:assert'); |
| const { describe, it } = require('node:test'); |
| |
| const x = ['x']; |
| |
| function createCircularObject() { |
| const obj = {}; |
| obj.self = obj; |
| obj.set = new Set([x, ['y']]); |
| return obj; |
| } |
| |
| function createDeepNestedObject() { |
| return { level1: { level2: { level3: 'deepValue' } } }; |
| } |
| |
| async function generateCryptoKey() { |
| const { KeyObject } = require('node:crypto'); |
| const { subtle } = globalThis.crypto; |
| |
| const cryptoKey = await subtle.generateKey( |
| { |
| name: 'HMAC', |
| hash: 'SHA-256', |
| length: 256, |
| }, |
| true, |
| ['sign', 'verify'] |
| ); |
| |
| const keyObject = KeyObject.from(cryptoKey); |
| |
| return { cryptoKey, keyObject }; |
| } |
| |
| describe('Object Comparison Tests', () => { |
| describe('partialDeepStrictEqual', () => { |
| describe('throws an error', () => { |
| const tests = [ |
| { |
| description: 'throws when only actual is provided', |
| actual: { a: 1 }, |
| expected: undefined, |
| }, |
| { |
| description: 'throws when unequal zeros are compared', |
| actual: 0, |
| expected: -0, |
| }, |
| { |
| description: 'throws when only expected is provided', |
| actual: undefined, |
| expected: { a: 1 }, |
| }, |
| { |
| description: 'throws when expected has more properties than actual', |
| actual: [1, 'two'], |
| expected: [1, 'two', true], |
| }, |
| { |
| description: 'throws because expected has seven 2 while actual has six one', |
| actual: [1, 2, 2, 2, 2, 2, 2, 3], |
| expected: [1, 2, 2, 2, 2, 2, 2, 2], |
| }, |
| { |
| description: 'throws when comparing two different sets with objects', |
| actual: new Set([{ a: 1 }]), |
| expected: new Set([{ a: 1 }, { b: 1 }]), |
| }, |
| |
| { |
| description: 'throws when comparing two WeakSet objects', |
| actual: new WeakSet(), |
| expected: new WeakSet(), |
| }, |
| { |
| description: 'throws when comparing two WeakMap objects', |
| actual: new WeakMap(), |
| expected: new WeakMap(), |
| }, |
| { |
| description: 'throws when comparing two different objects', |
| actual: { a: 1, b: 'string' }, |
| expected: { a: 2, b: 'string' }, |
| }, |
| { |
| description: |
| 'throws when comparing two objects with different nested objects', |
| actual: createDeepNestedObject(), |
| expected: { level1: { level2: { level3: 'differentValue' } } }, |
| }, |
| { |
| description: |
| 'throws when comparing two objects with different RegExp properties', |
| actual: { pattern: /abc/ }, |
| expected: { pattern: /def/ }, |
| }, |
| { |
| description: |
| 'throws when comparing two arrays with different elements', |
| actual: [1, 'two', true], |
| expected: [1, 'two', false], |
| }, |
| { |
| description: 'throws when comparing [0] with [-0]', |
| actual: [0], |
| expected: [-0], |
| }, |
| { |
| description: 'throws when comparing [0, 0, 0] with [0, -0]', |
| actual: [0, 0, 0], |
| expected: [0, -0], |
| }, |
| { |
| description: 'throws when comparing ["-0"] with [-0]', |
| actual: ['-0'], |
| expected: [-0], |
| }, |
| { |
| description: 'throws when comparing [-0] with [0]', |
| actual: [-0], |
| expected: [0], |
| }, |
| { |
| description: 'throws when comparing [-0] with ["-0"]', |
| actual: [-0], |
| expected: ['-0'], |
| }, |
| { |
| description: 'throws when comparing ["0"] with [0]', |
| actual: ['0'], |
| expected: [0], |
| }, |
| { |
| description: 'throws when comparing [0] with ["0"]', |
| actual: [0], |
| expected: ['0'], |
| }, |
| { |
| description: |
| 'throws when comparing two Date objects with different times', |
| actual: new Date(0), |
| expected: new Date(1), |
| }, |
| { |
| description: |
| 'throws when comparing two objects with different large number of properties', |
| actual: Object.fromEntries( |
| Array.from({ length: 100 }, (_, i) => [`key${i}`, i]) |
| ), |
| expected: Object.fromEntries( |
| Array.from({ length: 100 }, (_, i) => [`key${i}`, i + 1]) |
| ), |
| }, |
| { |
| description: |
| 'throws when comparing two objects with different Symbols', |
| actual: { [Symbol('test')]: 'symbol' }, |
| expected: { [Symbol('test')]: 'symbol' }, |
| }, |
| { |
| description: |
| 'throws when comparing two objects with different array properties', |
| actual: { a: [1, 2, 3] }, |
| expected: { a: [1, 2, 4] }, |
| }, |
| { |
| description: |
| 'throws when comparing two objects with different function properties', |
| actual: { fn: () => {} }, |
| expected: { fn: () => {} }, |
| }, |
| { |
| description: |
| 'throws when comparing two objects with different Error message', |
| actual: { error: new Error('Test error 1') }, |
| expected: { error: new Error('Test error 2') }, |
| }, |
| { |
| description: |
| 'throws when comparing two objects with missing cause on the actual Error', |
| actual: { error: new Error('Test error 1') }, |
| expected: { error: new Error('Test error 1', { cause: 42 }) }, |
| }, |
| { |
| description: |
| 'throws when comparing two objects with missing message on the actual Error', |
| actual: { error: new Error() }, |
| expected: { error: new Error('Test error 1') }, |
| }, |
| { |
| description: 'throws when comparing two Errors with missing cause on the actual Error', |
| actual: { error: new Error('Test error 1') }, |
| expected: { error: new Error('Test error 1', { cause: undefined }) }, |
| }, |
| { |
| description: 'throws when comparing two AggregateErrors with missing message on the actual Error', |
| actual: { error: new AggregateError([], 'Test error 1') }, |
| expected: { error: new AggregateError([new Error()], 'Test error 1') }, |
| }, |
| { |
| description: |
| 'throws when comparing two objects with different TypedArray instances and content', |
| actual: { typedArray: new Uint8Array([1, 2, 3]) }, |
| expected: { typedArray: new Uint8Array([4, 5, 6]) }, |
| }, |
| { |
| description: |
| 'throws when comparing two Map objects with different entries', |
| actual: new Map([ |
| ['key1', 'value1'], |
| ['key2', 'value2'], |
| ]), |
| expected: new Map([ |
| ['key1', 'value1'], |
| ['key3', 'value3'], |
| ]), |
| }, |
| { |
| description: |
| 'throws when comparing two Map objects with different keys', |
| actual: new Map([ |
| ['key1', 'value1'], |
| ['key2', 'value2'], |
| ]), |
| expected: new Map([ |
| ['key1', 'value1'], |
| ['key3', 'value2'], |
| ]), |
| }, |
| { |
| description: |
| 'throws when the expected Map has more entries than the actual Map', |
| actual: new Map([ |
| ['key1', 'value1'], |
| ['key2', 'value2'], |
| ]), |
| expected: new Map([ |
| ['key1', 'value1'], |
| ['key2', 'value2'], |
| ['key3', 'value3'], |
| ]), |
| }, |
| { |
| description: 'throws when the nested array in the Map is not a subset of the other nested array', |
| actual: new Map([ |
| ['key1', ['value1', 'value2']], |
| ['key2', 'value2'], |
| ]), |
| expected: new Map([ |
| ['key1', ['value3']], |
| ]), |
| }, |
| { |
| description: 'throws for maps with object keys and different values', |
| actual: new Map([ |
| [{ a: 1 }, 'value1'], |
| [{ b: 2 }, 'value2'], |
| [{ b: 2 }, 'value4'], |
| ]), |
| expected: new Map([ |
| [{ a: 1 }, 'value1'], |
| [{ b: 2 }, 'value3'], |
| ]), |
| }, |
| { |
| description: 'throws for maps with multiple identical object keys, just not enough', |
| actual: new Map([ |
| [{ a: 1 }, 'value1'], |
| [{ b: 1 }, 'value2'], |
| [{ a: 1 }, 'value1'], |
| ]), |
| expected: new Map([ |
| [{ a: 1 }, 'value1'], |
| [{ a: 1 }, 'value1'], |
| [{ a: 1 }, 'value1'], |
| ]), |
| }, |
| { |
| description: 'throws for Maps with mixed unequal entries', |
| actual: new Map([[{ a: 2 }, 1], [1, 1], [{ b: 1 }, 1], [[], 1], [2, 1], [{ a: 1 }, 1]]), |
| expected: new Map([[{ a: 1 }, 1], [[], 1], [2, 1], [{ a: 1 }, 1]]), |
| }, |
| { |
| description: 'throws for sets with different object values', |
| actual: new Set([ |
| { a: 1 }, |
| { a: 2 }, |
| { a: 1 }, |
| { a: 2 }, |
| ]), |
| expected: new Set([ |
| { a: 1 }, |
| { a: 2 }, |
| { a: 1 }, |
| { a: 1 }, |
| ]), |
| }, |
| { |
| description: |
| 'throws when comparing two TypedArray instances with different content', |
| actual: new Uint8Array(10), |
| expected: () => { |
| const typedArray2 = new Int8Array(10); |
| Object.defineProperty(typedArray2, Symbol.toStringTag, { |
| value: 'Uint8Array' |
| }); |
| Object.setPrototypeOf(typedArray2, Uint8Array.prototype); |
| |
| return typedArray2; |
| }, |
| }, |
| { |
| description: |
| 'throws when comparing two Set objects from different realms with different values', |
| actual: new vm.runInNewContext('new Set(["value1", "value2"])'), |
| expected: new Set(['value1', 'value3']), |
| }, |
| { |
| description: |
| 'throws when comparing two Set objects with different values', |
| actual: new Set(['value1', 'value2']), |
| expected: new Set(['value1', 'value3']), |
| }, |
| { |
| description: 'throws when comparing one subset object with another', |
| actual: { a: 1, b: 2, c: 3 }, |
| expected: { b: '2' }, |
| }, |
| { |
| description: 'throws when comparing one subset array with another', |
| actual: [1, 2, 3], |
| expected: ['2'], |
| }, |
| { |
| description: 'throws when comparing an array with symbol properties not matching', |
| actual: (() => { |
| const array = [1, 2, 3]; |
| array[Symbol.for('test')] = 'test'; |
| return array; |
| })(), |
| expected: (() => { |
| const array = [1, 2, 3]; |
| array[Symbol.for('test')] = 'different'; |
| return array; |
| })(), |
| }, |
| { |
| description: 'throws when comparing an array with extra properties not matching', |
| actual: (() => { |
| const array = [1, 2, 3]; |
| array.extra = 'test'; |
| return array; |
| })(), |
| expected: (() => { |
| const array = [1, 2, 3]; |
| array.extra = 'different'; |
| return array; |
| })(), |
| }, |
| { |
| description: 'throws when comparing a non matching sparse array', |
| actual: (() => { |
| const array = new Array(1000); |
| array[90] = 1; |
| array[92] = 2; |
| array[95] = 1; |
| array[96] = 2; |
| array.foo = 'bar'; |
| array.extra = 'test'; |
| return array; |
| })(), |
| expected: (() => { |
| const array = new Array(1000); |
| array[90] = 1; |
| array[92] = 1; |
| array[95] = 1; |
| array.extra = 'test'; |
| array.foo = 'bar'; |
| return array; |
| })(), |
| }, |
| { |
| description: 'throws when comparing a same length sparse array with actual less keys', |
| actual: (() => { |
| const array = new Array(1000); |
| array[90] = 1; |
| array[92] = 1; |
| return array; |
| })(), |
| expected: (() => { |
| const array = new Array(1000); |
| array[90] = 1; |
| array[92] = 1; |
| array[95] = 1; |
| return array; |
| })(), |
| }, |
| { |
| description: 'throws when comparing an array with symbol properties matching but other enumerability', |
| actual: (() => { |
| const array = [1, 2, 3]; |
| array[Symbol.for('abc')] = 'test'; |
| Object.defineProperty(array, Symbol.for('test'), { |
| value: 'test', |
| enumerable: false, |
| }); |
| array[Symbol.for('other')] = 'test'; |
| return array; |
| })(), |
| expected: (() => { |
| const array = [1, 2, 3]; |
| array[Symbol.for('test')] = 'test'; |
| return array; |
| })(), |
| }, |
| { |
| description: 'throws comparing an array with extra properties matching but other enumerability', |
| actual: (() => { |
| const array = [1, 2, 3]; |
| array.alsoIgnored = [{ nested: { property: true } }]; |
| Object.defineProperty(array, 'extra', { |
| value: 'test', |
| enumerable: false, |
| }); |
| array.ignored = 'test'; |
| return array; |
| })(), |
| expected: (() => { |
| const array = [1, 2, 3]; |
| array.extra = 'test'; |
| return array; |
| })(), |
| }, |
| { |
| description: 'throws when comparing an ArrayBuffer with a Uint8Array', |
| actual: new ArrayBuffer(3), |
| expected: new Uint8Array(3), |
| }, |
| { |
| description: 'throws when comparing an TypedArrays with symbol properties not matching', |
| actual: (() => { |
| const typed = new Uint8Array(3); |
| typed[Symbol.for('test')] = 'test'; |
| return typed; |
| })(), |
| expected: (() => { |
| const typed = new Uint8Array(3); |
| typed[Symbol.for('test')] = 'different'; |
| return typed; |
| })(), |
| }, |
| { |
| description: 'throws when comparing a ArrayBuffer with a SharedArrayBuffer', |
| actual: new ArrayBuffer(3), |
| expected: new SharedArrayBuffer(3), |
| }, |
| { |
| description: 'throws when comparing a SharedArrayBuffer with an ArrayBuffer', |
| actual: new SharedArrayBuffer(3), |
| expected: new ArrayBuffer(3), |
| }, |
| { |
| description: 'throws when comparing an Int16Array with a Uint16Array', |
| actual: new Int16Array(3), |
| expected: new Uint16Array(3), |
| }, |
| { |
| description: 'throws when comparing two dataviews with different buffers', |
| actual: { dataView: new DataView(new ArrayBuffer(3)) }, |
| expected: { dataView: new DataView(new ArrayBuffer(4)) }, |
| }, |
| { |
| description: 'throws because expected Uint8Array(SharedArrayBuffer) is not a subset of actual', |
| actual: { typedArray: new Uint8Array(new SharedArrayBuffer(3)) }, |
| expected: { typedArray: new Uint8Array(new SharedArrayBuffer(5)) }, |
| }, |
| { |
| description: 'throws because expected SharedArrayBuffer is not a subset of actual', |
| actual: { typedArray: new SharedArrayBuffer(3) }, |
| expected: { typedArray: new SharedArrayBuffer(5) }, |
| }, |
| { |
| description: 'throws when comparing a DataView with a TypedArray', |
| actual: { dataView: new DataView(new ArrayBuffer(3)) }, |
| expected: { dataView: new Uint8Array(3) }, |
| }, |
| { |
| description: 'throws when comparing a TypedArray with a DataView', |
| actual: { dataView: new Uint8Array(3) }, |
| expected: { dataView: new DataView(new ArrayBuffer(3)) }, |
| }, |
| { |
| description: 'throws when comparing Float16Array([+0.0]) with Float16Array([-0.0])', |
| actual: new Float16Array([+0.0]), |
| expected: new Float16Array([-0.0]), |
| }, |
| { |
| description: 'throws when comparing Float32Array([+0.0]) with Float32Array([-0.0])', |
| actual: new Float32Array([+0.0]), |
| expected: new Float32Array([-0.0]), |
| }, |
| { |
| description: 'throws when comparing two Uint8Array objects with non-matching entries', |
| actual: { typedArray: new Uint8Array([1, 2, 3, 4, 5]) }, |
| expected: { typedArray: new Uint8Array([1, 333, 2, 4]) }, |
| }, |
| { |
| description: 'throws when comparing two different urls', |
| actual: new URL('http://foo'), |
| expected: new URL('http://bar'), |
| }, |
| { |
| description: 'throws when comparing SharedArrayBuffers when expected has different elements actual', |
| actual: (() => { |
| const sharedBuffer = new SharedArrayBuffer(4 * Int32Array.BYTES_PER_ELEMENT); |
| const sharedArray = new Int32Array(sharedBuffer); |
| |
| sharedArray[0] = 1; |
| sharedArray[1] = 2; |
| sharedArray[2] = 3; |
| |
| return sharedBuffer; |
| })(), |
| expected: (() => { |
| const sharedBuffer = new SharedArrayBuffer(4 * Int32Array.BYTES_PER_ELEMENT); |
| const sharedArray = new Int32Array(sharedBuffer); |
| |
| sharedArray[0] = 1; |
| sharedArray[1] = 2; |
| sharedArray[2] = 6; |
| |
| return sharedBuffer; |
| })(), |
| }, |
| ]; |
| |
| if (common.hasCrypto) { |
| tests.push({ |
| description: |
| 'throws when comparing two objects with different CryptoKey instances objects', |
| actual: async () => { |
| return generateCryptoKey(); |
| }, |
| expected: async () => { |
| return generateCryptoKey(); |
| }, |
| }); |
| |
| const { createSecretKey } = require('node:crypto'); |
| |
| tests.push({ |
| description: |
| 'throws when comparing two objects with different KeyObject instances objects', |
| actual: createSecretKey(Buffer.alloc(1, 0)), |
| expected: createSecretKey(Buffer.alloc(1, 1)), |
| }); |
| } |
| |
| tests.forEach(({ description, actual, expected }) => { |
| it(description, () => { |
| assert.throws(() => assert.partialDeepStrictEqual(actual, expected), Error); |
| }); |
| }); |
| }); |
| }); |
| |
| describe('does not throw an error', () => { |
| const sym = Symbol('test'); |
| const func = () => {}; |
| |
| [ |
| { |
| description: 'compares two identical simple objects', |
| actual: { a: 1, b: 'string' }, |
| expected: { a: 1, b: 'string' }, |
| }, |
| { |
| description: 'compares two objects with different property order', |
| actual: { a: 1, b: 'string' }, |
| expected: { b: 'string', a: 1 }, |
| }, |
| { |
| description: 'compares two deeply nested objects with partial equality', |
| actual: { a: { nested: { property: true, some: 'other' } } }, |
| expected: { a: { nested: { property: true } } }, |
| }, |
| { |
| description: |
| 'compares plain objects from different realms', |
| actual: vm.runInNewContext(`({ |
| a: 1, |
| b: 2n, |
| c: "3", |
| d: /4/, |
| e: new Set([5]), |
| f: [6], |
| g: new Uint8Array() |
| })`), |
| expected: { b: 2n, e: new Set([5]), f: [6], g: new Uint8Array() }, |
| }, |
| { |
| description: 'compares two integers', |
| actual: 1, |
| expected: 1, |
| }, |
| { |
| description: 'compares two strings', |
| actual: '1', |
| expected: '1', |
| }, |
| { |
| description: 'compares two objects with nested objects', |
| actual: createDeepNestedObject(), |
| expected: createDeepNestedObject(), |
| }, |
| { |
| description: 'compares two objects with circular references', |
| actual: createCircularObject(), |
| expected: createCircularObject(), |
| }, |
| { |
| description: 'compares two arrays with identical elements', |
| actual: [1, 'two', true], |
| expected: [1, 'two', true], |
| }, |
| { |
| description: 'compares [0] with [0]', |
| actual: [0], |
| expected: [0], |
| }, |
| { |
| description: 'compares [-0] with [-0]', |
| actual: [-0], |
| expected: [-0], |
| }, |
| { |
| description: 'compares [0, -0, 0] with [0, 0]', |
| actual: [0, -0, 0], |
| expected: [0, 0], |
| }, |
| { |
| description: 'comparing an array with symbol properties matching', |
| actual: (() => { |
| const array = [1, 2, 3]; |
| array[Symbol.for('abc')] = 'test'; |
| array[Symbol.for('test')] = 'test'; |
| Object.defineProperty(array, Symbol.for('hidden'), { |
| value: 'hidden', |
| enumerable: false, |
| }); |
| return array; |
| })(), |
| expected: (() => { |
| const array = [1, 2, 3]; |
| array[Symbol.for('test')] = 'test'; |
| return array; |
| })(), |
| }, |
| { |
| description: 'comparing an array with extra properties matching', |
| actual: (() => { |
| const array = [1, 2, 3]; |
| array.alsoIgnored = [{ nested: { property: true } }]; |
| array.extra = 'test'; |
| array.ignored = 'test'; |
| return array; |
| })(), |
| expected: (() => { |
| const array = [1, 2, 3]; |
| array.extra = 'test'; |
| Object.defineProperty(array, 'ignored', { enumerable: false }); |
| Object.defineProperty(array, Symbol.for('hidden'), { |
| value: 'hidden', |
| enumerable: false, |
| }); |
| return array; |
| })(), |
| }, |
| { |
| description: 'compares two Date objects with the same time', |
| actual: new Date(0), |
| expected: new Date(0), |
| }, |
| { |
| description: 'compares two objects with large number of properties', |
| actual: Object.fromEntries( |
| Array.from({ length: 100 }, (_, i) => [`key${i}`, i]) |
| ), |
| expected: Object.fromEntries( |
| Array.from({ length: 100 }, (_, i) => [`key${i}`, i]) |
| ), |
| }, |
| { |
| description: 'compares two objects with Symbol properties', |
| actual: { [sym]: 'symbol' }, |
| expected: { [sym]: 'symbol' }, |
| }, |
| { |
| description: 'compares two objects with RegExp properties', |
| actual: { pattern: /abc/ }, |
| expected: { pattern: /abc/ }, |
| }, |
| { |
| description: 'compares two objects with identical function properties', |
| actual: { fn: func }, |
| expected: { fn: func }, |
| }, |
| { |
| description: 'compares two objects with mixed types of properties', |
| actual: { num: 1, str: 'test', bool: true, sym }, |
| expected: { num: 1, str: 'test', bool: true, sym }, |
| }, |
| { |
| description: 'compares two objects with Buffers', |
| actual: { buf: Buffer.from('Node.js') }, |
| expected: { buf: Buffer.from('Node.js') }, |
| }, |
| { |
| description: 'compares two objects with identical Error properties', |
| actual: { error: new Error('Test error') }, |
| expected: { error: new Error('Test error') }, |
| }, |
| { |
| description: 'compares two Uint8Array objects', |
| actual: { typedArray: new Uint8Array([1, 2, 3, 4, 5]) }, |
| expected: { typedArray: new Uint8Array([1, 2, 3, 5]) }, |
| }, |
| { |
| description: 'compares two Int16Array objects', |
| actual: { typedArray: new Int16Array([1, 2, 3, 4, 5]) }, |
| expected: { typedArray: new Int16Array([1, 2, 3]) }, |
| }, |
| { |
| description: 'compares two DataView objects with the same buffer and different views', |
| actual: { dataView: new DataView(new ArrayBuffer(8), 0, 4) }, |
| expected: { dataView: new DataView(new ArrayBuffer(8), 4, 4) }, |
| }, |
| { |
| description: 'compares two DataView objects with different buffers', |
| actual: { dataView: new DataView(new ArrayBuffer(8)) }, |
| expected: { dataView: new DataView(new ArrayBuffer(8)) }, |
| }, |
| { |
| description: 'compares two DataView objects with the same buffer and same views', |
| actual: { dataView: new DataView(new ArrayBuffer(8), 0, 8) }, |
| expected: { dataView: new DataView(new ArrayBuffer(8), 0, 8) }, |
| }, |
| { |
| description: 'compares two SharedArrayBuffers with the same length', |
| actual: new SharedArrayBuffer(3), |
| expected: new SharedArrayBuffer(3), |
| }, |
| { |
| description: 'compares two Uint8Array objects from SharedArrayBuffer', |
| actual: { typedArray: new Uint8Array(new SharedArrayBuffer(5)) }, |
| expected: { typedArray: new Uint8Array(new SharedArrayBuffer(3)) }, |
| }, |
| { |
| description: 'compares two Int16Array objects from SharedArrayBuffer', |
| actual: { typedArray: new Int16Array(new SharedArrayBuffer(10)) }, |
| expected: { typedArray: new Int16Array(new SharedArrayBuffer(6)) }, |
| }, |
| { |
| description: 'compares two DataView objects with the same SharedArrayBuffer and different views', |
| actual: { dataView: new DataView(new SharedArrayBuffer(8), 0, 4) }, |
| expected: { dataView: new DataView(new SharedArrayBuffer(8), 4, 4) }, |
| }, |
| { |
| description: 'compares two DataView objects with different SharedArrayBuffers', |
| actual: { dataView: new DataView(new SharedArrayBuffer(8)) }, |
| expected: { dataView: new DataView(new SharedArrayBuffer(8)) }, |
| }, |
| { |
| description: 'compares two DataView objects with the same SharedArrayBuffer and same views', |
| actual: { dataView: new DataView(new SharedArrayBuffer(8), 0, 8) }, |
| expected: { dataView: new DataView(new SharedArrayBuffer(8), 0, 8) }, |
| }, |
| { |
| description: 'compares two SharedArrayBuffers', |
| actual: { typedArray: new SharedArrayBuffer(5) }, |
| expected: { typedArray: new SharedArrayBuffer(3) }, |
| }, |
| { |
| description: 'compares two SharedArrayBuffers with data inside', |
| actual: (() => { |
| const sharedBuffer = new SharedArrayBuffer(4 * Int32Array.BYTES_PER_ELEMENT); |
| const sharedArray = new Int32Array(sharedBuffer); |
| |
| sharedArray[0] = 1; |
| sharedArray[1] = 2; |
| sharedArray[2] = 3; |
| sharedArray[3] = 4; |
| |
| return sharedBuffer; |
| })(), |
| expected: (() => { |
| const sharedBuffer = new SharedArrayBuffer(3 * Int32Array.BYTES_PER_ELEMENT); |
| const sharedArray = new Int32Array(sharedBuffer); |
| |
| sharedArray[0] = 1; |
| sharedArray[1] = 2; |
| sharedArray[2] = 3; |
| |
| return sharedBuffer; |
| })(), |
| }, |
| { |
| description: 'compares two Map objects with identical entries', |
| actual: new Map([ |
| ['key1', 'value1'], |
| ['key2', 'value2'], |
| ]), |
| expected: new Map([ |
| ['key1', 'value1'], |
| ['key2', 'value2'], |
| ]), |
| }, |
| { |
| description: 'compares two Map where one is a subset of the other', |
| actual: new Map([ |
| ['key1', { nested: { property: true } }], |
| ['key2', new Set([1, 2, 3])], |
| ['key3', new Uint8Array([1, 2, 3])], |
| ]), |
| expected: new Map([ |
| ['key1', { nested: { property: true } }], |
| ['key2', new Set([1, 2, 3])], |
| ['key3', new Uint8Array([1, 2, 3])], |
| ]) |
| }, |
| { |
| description: 'compares maps with object keys', |
| actual: new Map([ |
| [{ a: 1 }, 'value1'], |
| [{ a: 2 }, 'value2'], |
| [{ a: 2 }, 'value3'], |
| [{ a: 2 }, 'value3'], |
| [{ a: 2 }, 'value4'], |
| [{ a: 1 }, 'value2'], |
| ]), |
| expected: new Map([ |
| [{ a: 2 }, 'value3'], |
| [{ a: 1 }, 'value1'], |
| [{ a: 2 }, 'value3'], |
| [{ a: 1 }, 'value2'], |
| ]), |
| }, |
| { |
| describe: 'compares two simple sparse arrays', |
| actual: new Array(1_000), |
| expected: new Array(100), |
| }, |
| { |
| describe: 'compares two identical sparse arrays', |
| actual: (() => { |
| const array = new Array(100); |
| array[1] = 2; |
| return array; |
| })(), |
| expected: (() => { |
| const array = new Array(100); |
| array[1] = 2; |
| return array; |
| })(), |
| }, |
| { |
| describe: 'compares two big sparse arrays', |
| actual: (() => { |
| const array = new Array(150_000_000); |
| array[0] = 1; |
| array[1] = 2; |
| array[100] = 100n; |
| array[200_000] = 3; |
| array[1_200_000] = 4; |
| array[120_200_000] = []; |
| return array; |
| })(), |
| expected: (() => { |
| const array = new Array(100_000_000); |
| array[0] = 1; |
| array[1] = 2; |
| array[200_000] = 3; |
| array[1_200_000] = 4; |
| return array; |
| })(), |
| }, |
| { |
| describe: 'compares two array of objects', |
| actual: [{ a: 5 }], |
| expected: [{ a: 5 }], |
| }, |
| { |
| describe: 'compares two array of objects where expected is a subset of actual', |
| actual: [{ a: 5 }, { b: 5 }], |
| expected: [{ a: 5 }], |
| }, |
| { |
| description: 'compares two Set objects with identical objects', |
| actual: new Set([{ a: 1 }]), |
| expected: new Set([{ a: 1 }]), |
| }, |
| { |
| description: 'compares two Set objects where expected is a subset of actual', |
| actual: new Set([{ a: 1 }, { b: 1 }]), |
| expected: new Set([{ a: 1 }]), |
| }, |
| { |
| description: 'compares two Sets with mixed entries', |
| actual: new Set([{ b: 1 }, [], 1, { a: 1 }, 2, []]), |
| expected: new Set([{ a: 1 }, 2, []]), |
| }, |
| { |
| description: 'compares two Sets with mixed entries different order', |
| actual: new Set([{ a: 1 }, 1, { b: 1 }, [], 2, { a: 1 }]), |
| expected: new Set([{ a: 1 }, [], 2, { a: 1 }]), |
| }, |
| { |
| description: 'compares two Sets with mixed entries different order 2', |
| actual: new Set([{ a: 1 }, { a: 1 }, 1, { b: 1 }, [], 2, { a: 1 }]), |
| expected: new Set([{ a: 1 }, [], 2, { a: 1 }]), |
| }, |
| { |
| description: 'compares two Set objects with identical arrays', |
| actual: new Set(['value1', 'value2']), |
| expected: new Set(['value1', 'value2']), |
| }, |
| { |
| description: 'compares two Set objects', |
| actual: new Set(['value1', 'value2', 'value3']), |
| expected: new Set(['value1', 'value2']), |
| }, |
| { |
| description: |
| 'compares two Map objects from different realms with identical entries', |
| actual: new vm.runInNewContext( |
| 'new Map([["key1", "value1"], ["key2", "value2"]])' |
| ), |
| expected: new Map([ |
| ['key1', 'value1'], |
| ['key2', 'value2'], |
| ]), |
| }, |
| { |
| description: |
| 'compares two Map objects where expected is a subset of actual', |
| actual: new Map([ |
| ['key1', 'value1'], |
| ['key2', 'value2'], |
| ]), |
| expected: new Map([['key1', 'value1']]), |
| }, |
| { |
| description: |
| 'compares two deeply nested Maps', |
| actual: { |
| a: { |
| b: { |
| c: new Map([ |
| ['key1', 'value1'], |
| ['key2', 'value2'], |
| ]) |
| }, |
| z: [1, 2, 3] |
| } |
| }, |
| expected: { |
| a: { |
| z: [1, 2, 3], |
| b: { |
| c: new Map([['key1', 'value1']]) |
| } |
| } |
| }, |
| }, |
| { |
| description: 'compares Maps nested into Maps', |
| actual: new Map([ |
| ['key1', new Map([ |
| ['nestedKey1', 'nestedValue1'], |
| ['nestedKey2', 'nestedValue2'], |
| ])], |
| ['key2', 'value2'], |
| ]), |
| expected: new Map([ |
| ['key1', new Map([ |
| ['nestedKey1', 'nestedValue1'], |
| ])], |
| ]) |
| }, |
| { |
| description: 'compares Maps with nested arrays inside', |
| actual: new Map([ |
| ['key1', ['value1', 'value2']], |
| ['key2', 'value2'], |
| ]), |
| expected: new Map([ |
| ['key1', ['value1', 'value2']], |
| ]), |
| }, |
| { |
| description: |
| 'compares two objects with identical getter/setter properties', |
| actual: (() => { |
| let value = 'test'; |
| return Object.defineProperty({}, 'prop', { |
| get: () => value, |
| set: (newValue) => { |
| value = newValue; |
| }, |
| enumerable: true, |
| configurable: true, |
| }); |
| })(), |
| expected: (() => { |
| let value = 'test'; |
| return Object.defineProperty({}, 'prop', { |
| get: () => value, |
| set: (newValue) => { |
| value = newValue; |
| }, |
| enumerable: true, |
| configurable: true, |
| }); |
| })(), |
| }, |
| { |
| description: 'compares two objects with no prototype', |
| actual: { __proto__: null, prop: 'value' }, |
| expected: { __proto__: null, prop: 'value' }, |
| }, |
| { |
| description: |
| 'compares two objects with identical non-enumerable properties', |
| actual: (() => { |
| const obj = {}; |
| Object.defineProperty(obj, 'hidden', { |
| value: 'secret', |
| enumerable: false, |
| }); |
| return obj; |
| })(), |
| expected: (() => { |
| const obj = {}; |
| Object.defineProperty(obj, 'hidden', { |
| value: 'secret', |
| enumerable: false, |
| }); |
| return obj; |
| })(), |
| }, |
| { |
| description: 'compares two identical primitives, string', |
| actual: 'foo', |
| expected: 'foo', |
| }, |
| { |
| description: 'compares two identical primitives, number', |
| actual: 1, |
| expected: 1, |
| }, |
| { |
| description: 'compares two identical primitives, boolean', |
| actual: false, |
| expected: false, |
| }, |
| { |
| description: 'compares two identical primitives, null', |
| actual: null, |
| expected: null, |
| }, |
| { |
| description: 'compares two identical primitives, undefined', |
| actual: undefined, |
| expected: undefined, |
| }, |
| { |
| description: 'compares two identical primitives, Symbol', |
| actual: sym, |
| expected: sym, |
| }, |
| { |
| description: |
| 'compares one subset object with another', |
| actual: { a: 1, b: 2, c: 3 }, |
| expected: { b: 2 }, |
| }, |
| { |
| description: |
| 'compares one subset array with another', |
| actual: [1, 2, 3, 4, 5, 6, 7, 8, 9], |
| expected: [2, 5, 6, 7, 8], |
| }, |
| { |
| description: 'ensures that File extends Blob', |
| actual: Object.getPrototypeOf(File.prototype), |
| expected: Blob.prototype |
| }, |
| { |
| description: 'compares NaN with NaN', |
| actual: NaN, |
| expected: NaN, |
| }, |
| { |
| description: 'compares two identical urls', |
| actual: new URL('http://foo'), |
| expected: new URL('http://foo'), |
| }, |
| { |
| description: 'compares a more complex object with additional parts on the actual', |
| actual: [{ |
| foo: 'yarp', |
| nope: { |
| bar: '123', |
| a: [ 1, 2, 0 ], |
| c: {}, |
| b: [ |
| { |
| foo: 'yarp', |
| nope: { bar: '123', a: [ 1, 2, 0 ], c: {}, b: [] } |
| }, |
| { |
| foo: 'yarp', |
| nope: { bar: '123', a: [ 1, 2, 1 ], c: {}, b: [] } |
| }, |
| ], |
| } |
| }], |
| expected: [{ |
| foo: 'yarp', |
| nope: { |
| bar: '123', |
| c: {}, |
| b: [ |
| { foo: 'yarp', nope: { bar: '123', c: {}, b: [] } }, |
| { foo: 'yarp', nope: { bar: '123', c: {}, b: [] } }, |
| ], |
| } |
| }] |
| }, |
| { |
| description: 'comparing two Errors with missing cause on the expected Error', |
| actual: { error: new Error('Test error 1', { cause: 42 }) }, |
| expected: { error: new Error('Test error 1') }, |
| }, |
| { |
| description: 'comparing two Errors with cause set to undefined on the actual Error', |
| actual: { error: new Error('Test error 1', { cause: undefined }) }, |
| expected: { error: new Error('Test error 1') }, |
| }, |
| { |
| description: 'comparing two Errors with missing message on the expected Error', |
| actual: { error: new Error('Test error 1') }, |
| expected: { error: new Error() }, |
| }, |
| { |
| description: 'comparing two AggregateErrors with no message or errors on the expected Error', |
| actual: { error: new AggregateError([new Error(), 123]) }, |
| expected: { error: new AggregateError([]) }, |
| }, |
| ].forEach(({ description, actual, expected }) => { |
| it(description, () => { |
| assert.partialDeepStrictEqual(actual, expected); |
| }); |
| }); |
| }); |
| }); |
