mirror of
https://github.com/whoisclebs/lodash.git
synced 2026-02-03 00:27:50 +00:00
823 lines
24 KiB
TypeScript
823 lines
24 KiB
TypeScript
import assert from 'node:assert';
|
|
import lodashStable from 'lodash';
|
|
|
|
import {
|
|
noop,
|
|
create,
|
|
args,
|
|
realm,
|
|
arrayViews,
|
|
map,
|
|
promise,
|
|
set,
|
|
defineProperty,
|
|
document,
|
|
stubFalse,
|
|
} from './utils';
|
|
|
|
import isEqual from '../src/isEqual';
|
|
|
|
describe('isEqual', () => {
|
|
const symbol1 = Symbol ? Symbol('a') : true,
|
|
symbol2 = Symbol ? Symbol('b') : false;
|
|
|
|
it('should compare primitives', () => {
|
|
const pairs = [
|
|
[1, 1, true],
|
|
[1, Object(1), true],
|
|
[1, '1', false],
|
|
[1, 2, false],
|
|
[-0, -0, true],
|
|
[0, 0, true],
|
|
[0, Object(0), true],
|
|
[Object(0), Object(0), true],
|
|
[-0, 0, true],
|
|
[0, '0', false],
|
|
[0, null, false],
|
|
[NaN, NaN, true],
|
|
[NaN, Object(NaN), true],
|
|
[Object(NaN), Object(NaN), true],
|
|
[NaN, 'a', false],
|
|
[NaN, Infinity, false],
|
|
['a', 'a', true],
|
|
['a', Object('a'), true],
|
|
[Object('a'), Object('a'), true],
|
|
['a', 'b', false],
|
|
['a', ['a'], false],
|
|
[true, true, true],
|
|
[true, Object(true), true],
|
|
[Object(true), Object(true), true],
|
|
[true, 1, false],
|
|
[true, 'a', false],
|
|
[false, false, true],
|
|
[false, Object(false), true],
|
|
[Object(false), Object(false), true],
|
|
[false, 0, false],
|
|
[false, '', false],
|
|
[symbol1, symbol1, true],
|
|
[symbol1, Object(symbol1), true],
|
|
[Object(symbol1), Object(symbol1), true],
|
|
[symbol1, symbol2, false],
|
|
[null, null, true],
|
|
[null, undefined, false],
|
|
[null, {}, false],
|
|
[null, '', false],
|
|
[undefined, undefined, true],
|
|
[undefined, null, false],
|
|
[undefined, '', false],
|
|
];
|
|
|
|
const expected = lodashStable.map(pairs, (pair) => pair[2]);
|
|
|
|
const actual = lodashStable.map(pairs, (pair) => isEqual(pair[0], pair[1]));
|
|
|
|
assert.deepStrictEqual(actual, expected);
|
|
});
|
|
|
|
it('should compare arrays', () => {
|
|
let array1 = [true, null, 1, 'a', undefined],
|
|
array2 = [true, null, 1, 'a', undefined];
|
|
|
|
assert.strictEqual(isEqual(array1, array2), true);
|
|
|
|
array1 = [[1, 2, 3], new Date(2012, 4, 23), /x/, { e: 1 }];
|
|
array2 = [[1, 2, 3], new Date(2012, 4, 23), /x/, { e: 1 }];
|
|
|
|
assert.strictEqual(isEqual(array1, array2), true);
|
|
|
|
array1 = [1];
|
|
array1[2] = 3;
|
|
|
|
array2 = [1];
|
|
array2[1] = undefined;
|
|
array2[2] = 3;
|
|
|
|
assert.strictEqual(isEqual(array1, array2), true);
|
|
|
|
array1 = [
|
|
Object(1),
|
|
false,
|
|
Object('a'),
|
|
/x/,
|
|
new Date(2012, 4, 23),
|
|
['a', 'b', [Object('c')]],
|
|
{ a: 1 },
|
|
];
|
|
array2 = [
|
|
1,
|
|
Object(false),
|
|
'a',
|
|
/x/,
|
|
new Date(2012, 4, 23),
|
|
['a', Object('b'), ['c']],
|
|
{ a: 1 },
|
|
];
|
|
|
|
assert.strictEqual(isEqual(array1, array2), true);
|
|
|
|
array1 = [1, 2, 3];
|
|
array2 = [3, 2, 1];
|
|
|
|
assert.strictEqual(isEqual(array1, array2), false);
|
|
|
|
array1 = [1, 2];
|
|
array2 = [1, 2, 3];
|
|
|
|
assert.strictEqual(isEqual(array1, array2), false);
|
|
});
|
|
|
|
it('should treat arrays with identical values but different non-index properties as equal', () => {
|
|
let array1 = [1, 2, 3],
|
|
array2 = [1, 2, 3];
|
|
|
|
array1.every =
|
|
array1.filter =
|
|
array1.forEach =
|
|
array1.indexOf =
|
|
array1.lastIndexOf =
|
|
array1.map =
|
|
array1.some =
|
|
array1.reduce =
|
|
array1.reduceRight =
|
|
null;
|
|
|
|
array2.concat =
|
|
array2.join =
|
|
array2.pop =
|
|
array2.reverse =
|
|
array2.shift =
|
|
array2.slice =
|
|
array2.sort =
|
|
array2.splice =
|
|
array2.unshift =
|
|
null;
|
|
|
|
assert.strictEqual(isEqual(array1, array2), true);
|
|
|
|
array1 = [1, 2, 3];
|
|
array1.a = 1;
|
|
|
|
array2 = [1, 2, 3];
|
|
array2.b = 1;
|
|
|
|
assert.strictEqual(isEqual(array1, array2), true);
|
|
|
|
array1 = /c/.exec('abcde');
|
|
array2 = ['c'];
|
|
|
|
assert.strictEqual(isEqual(array1, array2), true);
|
|
});
|
|
|
|
it('should compare sparse arrays', () => {
|
|
const array = Array(1);
|
|
|
|
assert.strictEqual(isEqual(array, Array(1)), true);
|
|
assert.strictEqual(isEqual(array, [undefined]), true);
|
|
assert.strictEqual(isEqual(array, Array(2)), false);
|
|
});
|
|
|
|
it('should compare plain objects', () => {
|
|
let object1 = { a: true, b: null, c: 1, d: 'a', e: undefined },
|
|
object2 = { a: true, b: null, c: 1, d: 'a', e: undefined };
|
|
|
|
assert.strictEqual(isEqual(object1, object2), true);
|
|
|
|
object1 = { a: [1, 2, 3], b: new Date(2012, 4, 23), c: /x/, d: { e: 1 } };
|
|
object2 = { a: [1, 2, 3], b: new Date(2012, 4, 23), c: /x/, d: { e: 1 } };
|
|
|
|
assert.strictEqual(isEqual(object1, object2), true);
|
|
|
|
object1 = { a: 1, b: 2, c: 3 };
|
|
object2 = { a: 3, b: 2, c: 1 };
|
|
|
|
assert.strictEqual(isEqual(object1, object2), false);
|
|
|
|
object1 = { a: 1, b: 2, c: 3 };
|
|
object2 = { d: 1, e: 2, f: 3 };
|
|
|
|
assert.strictEqual(isEqual(object1, object2), false);
|
|
|
|
object1 = { a: 1, b: 2 };
|
|
object2 = { a: 1, b: 2, c: 3 };
|
|
|
|
assert.strictEqual(isEqual(object1, object2), false);
|
|
});
|
|
|
|
it('should compare objects regardless of key order', () => {
|
|
const object1 = { a: 1, b: 2, c: 3 },
|
|
object2 = { c: 3, a: 1, b: 2 };
|
|
|
|
assert.strictEqual(isEqual(object1, object2), true);
|
|
});
|
|
|
|
it('should compare nested objects', () => {
|
|
const object1 = {
|
|
a: [1, 2, 3],
|
|
b: true,
|
|
c: Object(1),
|
|
d: 'a',
|
|
e: {
|
|
f: ['a', Object('b'), 'c'],
|
|
g: Object(false),
|
|
h: new Date(2012, 4, 23),
|
|
i: noop,
|
|
j: 'a',
|
|
},
|
|
};
|
|
|
|
const object2 = {
|
|
a: [1, Object(2), 3],
|
|
b: Object(true),
|
|
c: 1,
|
|
d: Object('a'),
|
|
e: {
|
|
f: ['a', 'b', 'c'],
|
|
g: false,
|
|
h: new Date(2012, 4, 23),
|
|
i: noop,
|
|
j: 'a',
|
|
},
|
|
};
|
|
|
|
assert.strictEqual(isEqual(object1, object2), true);
|
|
});
|
|
|
|
it('should compare object instances', () => {
|
|
function Foo() {
|
|
this.a = 1;
|
|
}
|
|
Foo.prototype.a = 1;
|
|
|
|
function Bar() {
|
|
this.a = 1;
|
|
}
|
|
Bar.prototype.a = 2;
|
|
|
|
assert.strictEqual(isEqual(new Foo(), new Foo()), true);
|
|
assert.strictEqual(isEqual(new Foo(), new Bar()), false);
|
|
assert.strictEqual(isEqual({ a: 1 }, new Foo()), false);
|
|
assert.strictEqual(isEqual({ a: 2 }, new Bar()), false);
|
|
});
|
|
|
|
it('should compare objects with constructor properties', () => {
|
|
assert.strictEqual(isEqual({ constructor: 1 }, { constructor: 1 }), true);
|
|
assert.strictEqual(isEqual({ constructor: 1 }, { constructor: '1' }), false);
|
|
assert.strictEqual(isEqual({ constructor: [1] }, { constructor: [1] }), true);
|
|
assert.strictEqual(isEqual({ constructor: [1] }, { constructor: ['1'] }), false);
|
|
assert.strictEqual(isEqual({ constructor: Object }, {}), false);
|
|
});
|
|
|
|
it('should compare arrays with circular references', () => {
|
|
let array1 = [],
|
|
array2 = [];
|
|
|
|
array1.push(array1);
|
|
array2.push(array2);
|
|
|
|
assert.strictEqual(isEqual(array1, array2), true);
|
|
|
|
array1.push('b');
|
|
array2.push('b');
|
|
|
|
assert.strictEqual(isEqual(array1, array2), true);
|
|
|
|
array1.push('c');
|
|
array2.push('d');
|
|
|
|
assert.strictEqual(isEqual(array1, array2), false);
|
|
|
|
array1 = ['a', 'b', 'c'];
|
|
array1[1] = array1;
|
|
array2 = ['a', ['a', 'b', 'c'], 'c'];
|
|
|
|
assert.strictEqual(isEqual(array1, array2), false);
|
|
});
|
|
|
|
it('should have transitive equivalence for circular references of arrays', () => {
|
|
const array1 = [],
|
|
array2 = [array1],
|
|
array3 = [array2];
|
|
|
|
array1[0] = array1;
|
|
|
|
assert.strictEqual(isEqual(array1, array2), true);
|
|
assert.strictEqual(isEqual(array2, array3), true);
|
|
assert.strictEqual(isEqual(array1, array3), true);
|
|
});
|
|
|
|
it('should compare objects with circular references', () => {
|
|
let object1 = {},
|
|
object2 = {};
|
|
|
|
object1.a = object1;
|
|
object2.a = object2;
|
|
|
|
assert.strictEqual(isEqual(object1, object2), true);
|
|
|
|
object1.b = 0;
|
|
object2.b = Object(0);
|
|
|
|
assert.strictEqual(isEqual(object1, object2), true);
|
|
|
|
object1.c = Object(1);
|
|
object2.c = Object(2);
|
|
|
|
assert.strictEqual(isEqual(object1, object2), false);
|
|
|
|
object1 = { a: 1, b: 2, c: 3 };
|
|
object1.b = object1;
|
|
object2 = { a: 1, b: { a: 1, b: 2, c: 3 }, c: 3 };
|
|
|
|
assert.strictEqual(isEqual(object1, object2), false);
|
|
});
|
|
|
|
it('should have transitive equivalence for circular references of objects', () => {
|
|
const object1 = {},
|
|
object2 = { a: object1 },
|
|
object3 = { a: object2 };
|
|
|
|
object1.a = object1;
|
|
|
|
assert.strictEqual(isEqual(object1, object2), true);
|
|
assert.strictEqual(isEqual(object2, object3), true);
|
|
assert.strictEqual(isEqual(object1, object3), true);
|
|
});
|
|
|
|
it('should compare objects with multiple circular references', () => {
|
|
const array1 = [{}],
|
|
array2 = [{}];
|
|
|
|
(array1[0].a = array1).push(array1);
|
|
(array2[0].a = array2).push(array2);
|
|
|
|
assert.strictEqual(isEqual(array1, array2), true);
|
|
|
|
array1[0].b = 0;
|
|
array2[0].b = Object(0);
|
|
|
|
assert.strictEqual(isEqual(array1, array2), true);
|
|
|
|
array1[0].c = Object(1);
|
|
array2[0].c = Object(2);
|
|
|
|
assert.strictEqual(isEqual(array1, array2), false);
|
|
});
|
|
|
|
it('should compare objects with complex circular references', () => {
|
|
const object1 = {
|
|
foo: { b: { c: { d: {} } } },
|
|
bar: { a: 2 },
|
|
};
|
|
|
|
const object2 = {
|
|
foo: { b: { c: { d: {} } } },
|
|
bar: { a: 2 },
|
|
};
|
|
|
|
object1.foo.b.c.d = object1;
|
|
object1.bar.b = object1.foo.b;
|
|
|
|
object2.foo.b.c.d = object2;
|
|
object2.bar.b = object2.foo.b;
|
|
|
|
assert.strictEqual(isEqual(object1, object2), true);
|
|
});
|
|
|
|
it('should compare objects with shared property values', () => {
|
|
const object1 = {
|
|
a: [1, 2],
|
|
};
|
|
|
|
const object2 = {
|
|
a: [1, 2],
|
|
b: [1, 2],
|
|
};
|
|
|
|
object1.b = object1.a;
|
|
|
|
assert.strictEqual(isEqual(object1, object2), true);
|
|
});
|
|
|
|
it('should treat objects created by `Object.create(null)` like plain objects', () => {
|
|
function Foo() {
|
|
this.a = 1;
|
|
}
|
|
Foo.prototype.constructor = null;
|
|
|
|
const object1 = create(null);
|
|
object1.a = 1;
|
|
|
|
const object2 = { a: 1 };
|
|
|
|
assert.strictEqual(isEqual(object1, object2), true);
|
|
assert.strictEqual(isEqual(new Foo(), object2), false);
|
|
});
|
|
|
|
it('should avoid common type coercions', () => {
|
|
assert.strictEqual(isEqual(true, Object(false)), false);
|
|
assert.strictEqual(isEqual(Object(false), Object(0)), false);
|
|
assert.strictEqual(isEqual(false, Object('')), false);
|
|
assert.strictEqual(isEqual(Object(36), Object('36')), false);
|
|
assert.strictEqual(isEqual(0, ''), false);
|
|
assert.strictEqual(isEqual(1, true), false);
|
|
assert.strictEqual(isEqual(1337756400000, new Date(2012, 4, 23)), false);
|
|
assert.strictEqual(isEqual('36', 36), false);
|
|
assert.strictEqual(isEqual(36, '36'), false);
|
|
});
|
|
|
|
it('should compare `arguments` objects', () => {
|
|
const args1 = (function () {
|
|
return arguments;
|
|
})(),
|
|
args2 = (function () {
|
|
return arguments;
|
|
})(),
|
|
args3 = (function () {
|
|
return arguments;
|
|
})(1, 2);
|
|
|
|
assert.strictEqual(isEqual(args1, args2), true);
|
|
assert.strictEqual(isEqual(args1, args3), false);
|
|
});
|
|
|
|
it('should treat `arguments` objects like `Object` objects', () => {
|
|
const object = { '0': 1, '1': 2, '2': 3 };
|
|
|
|
function Foo() {}
|
|
Foo.prototype = object;
|
|
|
|
assert.strictEqual(isEqual(args, object), true);
|
|
assert.strictEqual(isEqual(object, args), true);
|
|
assert.strictEqual(isEqual(args, new Foo()), false);
|
|
assert.strictEqual(isEqual(new Foo(), args), false);
|
|
});
|
|
|
|
it('should compare array buffers', () => {
|
|
if (ArrayBuffer) {
|
|
const buffer = new Int8Array([-1]).buffer;
|
|
|
|
assert.strictEqual(isEqual(buffer, new Uint8Array([255]).buffer), true);
|
|
assert.strictEqual(isEqual(buffer, new ArrayBuffer(1)), false);
|
|
}
|
|
});
|
|
|
|
it('should compare array views', () => {
|
|
lodashStable.times(2, (index) => {
|
|
const ns = index ? realm : root;
|
|
|
|
const pairs = lodashStable.map(arrayViews, (type, viewIndex) => {
|
|
const otherType = arrayViews[(viewIndex + 1) % arrayViews.length],
|
|
CtorA =
|
|
ns[type] ||
|
|
function (n) {
|
|
this.n = n;
|
|
},
|
|
CtorB =
|
|
ns[otherType] ||
|
|
function (n) {
|
|
this.n = n;
|
|
},
|
|
bufferA = ns[type] ? new ns.ArrayBuffer(8) : 8,
|
|
bufferB = ns[otherType] ? new ns.ArrayBuffer(8) : 8,
|
|
bufferC = ns[otherType] ? new ns.ArrayBuffer(16) : 16;
|
|
|
|
return [
|
|
new CtorA(bufferA),
|
|
new CtorA(bufferA),
|
|
new CtorB(bufferB),
|
|
new CtorB(bufferC),
|
|
];
|
|
});
|
|
|
|
const expected = lodashStable.map(pairs, lodashStable.constant([true, false, false]));
|
|
|
|
const actual = lodashStable.map(pairs, (pair) => [
|
|
isEqual(pair[0], pair[1]),
|
|
isEqual(pair[0], pair[2]),
|
|
isEqual(pair[2], pair[3]),
|
|
]);
|
|
|
|
assert.deepStrictEqual(actual, expected);
|
|
});
|
|
});
|
|
|
|
it('should compare buffers', () => {
|
|
if (Buffer) {
|
|
const buffer = new Buffer([1]);
|
|
|
|
assert.strictEqual(isEqual(buffer, new Buffer([1])), true);
|
|
assert.strictEqual(isEqual(buffer, new Buffer([2])), false);
|
|
assert.strictEqual(isEqual(buffer, new Uint8Array([1])), false);
|
|
}
|
|
});
|
|
|
|
it('should compare date objects', () => {
|
|
const date = new Date(2012, 4, 23);
|
|
|
|
assert.strictEqual(isEqual(date, new Date(2012, 4, 23)), true);
|
|
assert.strictEqual(isEqual(new Date('a'), new Date('b')), true);
|
|
assert.strictEqual(isEqual(date, new Date(2013, 3, 25)), false);
|
|
assert.strictEqual(isEqual(date, { getTime: lodashStable.constant(+date) }), false);
|
|
});
|
|
|
|
it('should compare error objects', () => {
|
|
const pairs = lodashStable.map(
|
|
[
|
|
'Error',
|
|
'EvalError',
|
|
'RangeError',
|
|
'ReferenceError',
|
|
'SyntaxError',
|
|
'TypeError',
|
|
'URIError',
|
|
],
|
|
(type, index, errorTypes) => {
|
|
const otherType = errorTypes[++index % errorTypes.length],
|
|
CtorA = root[type],
|
|
CtorB = root[otherType];
|
|
|
|
return [new CtorA('a'), new CtorA('a'), new CtorB('a'), new CtorB('b')];
|
|
},
|
|
);
|
|
|
|
const expected = lodashStable.map(pairs, lodashStable.constant([true, false, false]));
|
|
|
|
const actual = lodashStable.map(pairs, (pair) => [
|
|
isEqual(pair[0], pair[1]),
|
|
isEqual(pair[0], pair[2]),
|
|
isEqual(pair[2], pair[3]),
|
|
]);
|
|
|
|
assert.deepStrictEqual(actual, expected);
|
|
});
|
|
|
|
it('should compare functions', () => {
|
|
function a() {
|
|
return 1 + 2;
|
|
}
|
|
function b() {
|
|
return 1 + 2;
|
|
}
|
|
|
|
assert.strictEqual(isEqual(a, a), true);
|
|
assert.strictEqual(isEqual(a, b), false);
|
|
});
|
|
|
|
it('should compare maps', () => {
|
|
if (Map) {
|
|
lodashStable.each(
|
|
[
|
|
[map, new Map()],
|
|
[map, realm.map],
|
|
],
|
|
(maps) => {
|
|
const map1 = maps[0],
|
|
map2 = maps[1];
|
|
|
|
map1.set('a', 1);
|
|
map2.set('b', 2);
|
|
assert.strictEqual(isEqual(map1, map2), false);
|
|
|
|
map1.set('b', 2);
|
|
map2.set('a', 1);
|
|
assert.strictEqual(isEqual(map1, map2), true);
|
|
|
|
map1.delete('a');
|
|
map1.set('a', 1);
|
|
assert.strictEqual(isEqual(map1, map2), true);
|
|
|
|
map2.delete('a');
|
|
assert.strictEqual(isEqual(map1, map2), false);
|
|
|
|
map1.clear();
|
|
map2.clear();
|
|
},
|
|
);
|
|
}
|
|
});
|
|
|
|
it('should compare maps with circular references', () => {
|
|
if (Map) {
|
|
const map1 = new Map(),
|
|
map2 = new Map();
|
|
|
|
map1.set('a', map1);
|
|
map2.set('a', map2);
|
|
assert.strictEqual(isEqual(map1, map2), true);
|
|
|
|
map1.set('b', 1);
|
|
map2.set('b', 2);
|
|
assert.strictEqual(isEqual(map1, map2), false);
|
|
}
|
|
});
|
|
|
|
it('should compare promises by reference', () => {
|
|
if (promise) {
|
|
lodashStable.each(
|
|
[
|
|
[promise, Promise.resolve(1)],
|
|
[promise, realm.promise],
|
|
],
|
|
(promises) => {
|
|
const promise1 = promises[0],
|
|
promise2 = promises[1];
|
|
|
|
assert.strictEqual(isEqual(promise1, promise2), false);
|
|
assert.strictEqual(isEqual(promise1, promise1), true);
|
|
},
|
|
);
|
|
}
|
|
});
|
|
|
|
it('should compare regexes', () => {
|
|
assert.strictEqual(isEqual(/x/gim, /x/gim), true);
|
|
assert.strictEqual(isEqual(/x/gim, /x/gim), true);
|
|
assert.strictEqual(isEqual(/x/gi, /x/g), false);
|
|
assert.strictEqual(isEqual(/x/, /y/), false);
|
|
assert.strictEqual(
|
|
isEqual(/x/g, { global: true, ignoreCase: false, multiline: false, source: 'x' }),
|
|
false,
|
|
);
|
|
});
|
|
|
|
it('should compare sets', () => {
|
|
if (Set) {
|
|
lodashStable.each(
|
|
[
|
|
[set, new Set()],
|
|
[set, realm.set],
|
|
],
|
|
(sets) => {
|
|
const set1 = sets[0],
|
|
set2 = sets[1];
|
|
|
|
set1.add(1);
|
|
set2.add(2);
|
|
assert.strictEqual(isEqual(set1, set2), false);
|
|
|
|
set1.add(2);
|
|
set2.add(1);
|
|
assert.strictEqual(isEqual(set1, set2), true);
|
|
|
|
set1.delete(1);
|
|
set1.add(1);
|
|
assert.strictEqual(isEqual(set1, set2), true);
|
|
|
|
set2.delete(1);
|
|
assert.strictEqual(isEqual(set1, set2), false);
|
|
|
|
set1.clear();
|
|
set2.clear();
|
|
},
|
|
);
|
|
}
|
|
});
|
|
|
|
it('should compare sets with circular references', () => {
|
|
if (Set) {
|
|
const set1 = new Set(),
|
|
set2 = new Set();
|
|
|
|
set1.add(set1);
|
|
set2.add(set2);
|
|
assert.strictEqual(isEqual(set1, set2), true);
|
|
|
|
set1.add(1);
|
|
set2.add(2);
|
|
assert.strictEqual(isEqual(set1, set2), false);
|
|
}
|
|
});
|
|
|
|
it('should compare symbol properties', () => {
|
|
if (Symbol) {
|
|
const object1 = { a: 1 },
|
|
object2 = { a: 1 };
|
|
|
|
object1[symbol1] = { a: { b: 2 } };
|
|
object2[symbol1] = { a: { b: 2 } };
|
|
|
|
defineProperty(object2, symbol2, {
|
|
configurable: true,
|
|
enumerable: false,
|
|
writable: true,
|
|
value: 2,
|
|
});
|
|
|
|
assert.strictEqual(isEqual(object1, object2), true);
|
|
|
|
object2[symbol1] = { a: 1 };
|
|
assert.strictEqual(isEqual(object1, object2), false);
|
|
|
|
delete object2[symbol1];
|
|
object2[Symbol('a')] = { a: { b: 2 } };
|
|
assert.strictEqual(isEqual(object1, object2), false);
|
|
}
|
|
});
|
|
|
|
it('should compare wrapped values', () => {
|
|
const stamp = +new Date();
|
|
|
|
const values = [
|
|
[
|
|
[1, 2],
|
|
[1, 2],
|
|
[1, 2, 3],
|
|
],
|
|
[true, true, false],
|
|
[new Date(stamp), new Date(stamp), new Date(stamp - 100)],
|
|
[
|
|
{ a: 1, b: 2 },
|
|
{ a: 1, b: 2 },
|
|
{ a: 1, b: 1 },
|
|
],
|
|
[1, 1, 2],
|
|
[NaN, NaN, Infinity],
|
|
[/x/, /x/, /x/i],
|
|
['a', 'a', 'A'],
|
|
];
|
|
|
|
lodashStable.each(values, (vals) => {
|
|
let wrapped1 = _(vals[0]),
|
|
wrapped2 = _(vals[1]),
|
|
actual = wrapped1.isEqual(wrapped2);
|
|
|
|
assert.strictEqual(actual, true);
|
|
assert.strictEqual(isEqual(_(actual), _(true)), true);
|
|
|
|
wrapped1 = _(vals[0]);
|
|
wrapped2 = _(vals[2]);
|
|
|
|
actual = wrapped1.isEqual(wrapped2);
|
|
assert.strictEqual(actual, false);
|
|
assert.strictEqual(isEqual(_(actual), _(false)), true);
|
|
});
|
|
});
|
|
|
|
it('should compare wrapped and non-wrapped values', () => {
|
|
let object1 = _({ a: 1, b: 2 }),
|
|
object2 = { a: 1, b: 2 };
|
|
|
|
assert.strictEqual(object1.isEqual(object2), true);
|
|
assert.strictEqual(isEqual(object1, object2), true);
|
|
|
|
object1 = _({ a: 1, b: 2 });
|
|
object2 = { a: 1, b: 1 };
|
|
|
|
assert.strictEqual(object1.isEqual(object2), false);
|
|
assert.strictEqual(isEqual(object1, object2), false);
|
|
});
|
|
|
|
it('should work as an iteratee for `_.every`', () => {
|
|
const actual = lodashStable.every([1, 1, 1], lodashStable.partial(isEqual, 1));
|
|
assert.ok(actual);
|
|
});
|
|
|
|
it('should not error on DOM elements', () => {
|
|
if (document) {
|
|
const element1 = document.createElement('div'),
|
|
element2 = element1.cloneNode(true);
|
|
|
|
try {
|
|
assert.strictEqual(isEqual(element1, element2), false);
|
|
} catch (e) {
|
|
assert.ok(false, e.message);
|
|
}
|
|
}
|
|
});
|
|
|
|
it('should return `true` for like-objects from different documents', () => {
|
|
if (realm.object) {
|
|
assert.strictEqual(isEqual([1], realm.array), true);
|
|
assert.strictEqual(isEqual([2], realm.array), false);
|
|
assert.strictEqual(isEqual({ a: 1 }, realm.object), true);
|
|
assert.strictEqual(isEqual({ a: 2 }, realm.object), false);
|
|
}
|
|
});
|
|
|
|
it('should return `false` for objects with custom `toString` methods', () => {
|
|
let primitive,
|
|
object = {
|
|
toString: function () {
|
|
return primitive;
|
|
},
|
|
},
|
|
values = [true, null, 1, 'a', undefined],
|
|
expected = lodashStable.map(values, stubFalse);
|
|
|
|
const actual = lodashStable.map(values, (value) => {
|
|
primitive = value;
|
|
return isEqual(object, value);
|
|
});
|
|
|
|
assert.deepStrictEqual(actual, expected);
|
|
});
|
|
|
|
it('should return an unwrapped value when implicitly chaining', () => {
|
|
assert.strictEqual(_('a').isEqual('a'), true);
|
|
});
|
|
|
|
it('should return a wrapped value when explicitly chaining', () => {
|
|
assert.ok(_('a').chain().isEqual('a') instanceof _);
|
|
});
|
|
});
|