Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Allow circular references (on old browsers as well) #5

Merged
merged 2 commits into from
May 6, 2016
Merged

Allow circular references (on old browsers as well) #5

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
91c4b48
fix(universal-deep-strict-equal): use indexof ponyfill for old IEs
twada May 6, 2016
2951373
test(universal-deep-strict-equal): use boolean expressions for testing
twada May 6, 2016
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
10 changes: 6 additions & 4 deletions index.js
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -26,6 +26,7 @@

var Buffer = require('buffer').Buffer;
var compare = Buffer.compare;
var indexOf = require('indexof');
var filter = require('array-filter');
var pSlice = Array.prototype.slice;
var getPrototypeOf = Object.getPrototypeOf || function(obj) {
Expand Down Expand Up @@ -105,7 +106,7 @@ var objectKeys = (function () {
isEnumerable(obj, 'byteOffset') &&
isEnumerable(obj, 'byteLength')) {
return filter(keys(obj), function (k) {
return OLD_V8_ARRAY_BUFFER_ENUM.indexOf(k) === -1;
return indexOf(OLD_V8_ARRAY_BUFFER_ENUM, k) === -1;
});
} else {
return keys(obj);
Expand Down Expand Up @@ -163,17 +164,18 @@ function _deepEqual(actual, expected, strict, memos) {
// accounts for both named and indexed properties on Arrays.
} else {
memos = memos || {actual: [], expected: []};
var actualIndex = memos.actual.indexOf(actual);

var actualIndex = indexOf(memos.actual, actual);
if (actualIndex !== -1) {
if (actualIndex === memos.expected.indexOf(expected)) {
if (actualIndex === indexOf(memos.expected, expected)) {
return true;
}
}

memos.actual.push(actual);
memos.expected.push(expected);

return objEquiv(actual, expected, strict, memos)
return objEquiv(actual, expected, strict, memos);
}
}

Expand Down
1 change: 1 addition & 0 deletions package.json
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -10,6 +10,7 @@
"bugs": "https://github.com/twada/universal-deep-strict-equal/issues",
"dependencies": {
"array-filter": "^1.0.0",
"indexof": "0.0.1",
"object-keys": "^1.0.9"
},
"devDependencies": {
Expand Down
20 changes: 4 additions & 16 deletions test/test-assert-typedarray-deepequal.js
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -4,17 +4,8 @@
var _deepEqual = require('..');
var assert = require('assert');

function deepEqual(actual, expected, message) {
if (!_deepEqual(actual, expected, false)) {
assert.fail(actual, expected, message, 'deepEqual', deepEqual);
}
};

function makeBlock(f) {
var args = Array.prototype.slice.call(arguments, 1);
return function() {
return f.apply(this, args);
};
function deepEqual (actual, expected) {
return _deepEqual(actual, expected, false);
}

function supportsTypedArray() {
Expand Down Expand Up @@ -62,15 +53,12 @@ var notEqualArrayPairs = [
describe('TypedArray deepEqual', function () {
equalArrayPairs.forEach(function (arrayPair, idx) {
it('equalArrayPairs - ' + idx, function () {
deepEqual(arrayPair[0], arrayPair[1]);
assert(deepEqual(arrayPair[0], arrayPair[1]));
});
});
notEqualArrayPairs.forEach(function (arrayPair, idx) {
it('notEqualArrayPairs - ' + idx, function () {
assert.throws(
makeBlock(deepEqual, arrayPair[0], arrayPair[1]),
assert.AssertionError
);
assert(!deepEqual(arrayPair[0], arrayPair[1]));
});
});
});
Expand Down
115 changes: 46 additions & 69 deletions test/test-deep-equal.js
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -5,78 +5,60 @@ var _deepEqual = require('..');
var assert = require('assert');
var keys = Object.keys || require('object-keys');

function deepEqual(actual, expected, message) {
if (!_deepEqual(actual, expected, false)) {
assert.fail(actual, expected, message, 'deepEqual', deepEqual);
}
};

function makeBlock(f) {
var args = Array.prototype.slice.call(arguments, 1);
return function() {
return f.apply(this, args);
};
function deepEqual (actual, expected) {
return _deepEqual(actual, expected, false);
}

describe('deepEqual', function () {

it('7.2', function () {
assert.doesNotThrow(makeBlock(deepEqual, new Date(2000, 3, 14),
new Date(2000, 3, 14)),
'deepEqual(new Date(2000, 3, 14), new Date(2000, 3, 14))');

assert.throws(makeBlock(deepEqual, new Date(), new Date(2000, 3, 14)),
assert.AssertionError,
'deepEqual(new Date(), new Date(2000, 3, 14))');
assert(deepEqual(new Date(2000, 3, 14), new Date(2000, 3, 14)), 'deepEqual(new Date(2000, 3, 14), new Date(2000, 3, 14))');
assert(!deepEqual(new Date(), new Date(2000, 3, 14)), 'deepEqual(new Date(), new Date(2000, 3, 14))');
});


it('7.3', function () {
assert.doesNotThrow(makeBlock(deepEqual, /a/, /a/));
assert.doesNotThrow(makeBlock(deepEqual, /a/g, /a/g));
assert.doesNotThrow(makeBlock(deepEqual, /a/i, /a/i));
assert.doesNotThrow(makeBlock(deepEqual, /a/m, /a/m));
assert.doesNotThrow(makeBlock(deepEqual, /a/igm, /a/igm));
assert.throws(makeBlock(deepEqual, /ab/, /a/));
assert.throws(makeBlock(deepEqual, /a/g, /a/));
assert.throws(makeBlock(deepEqual, /a/i, /a/));
assert.throws(makeBlock(deepEqual, /a/m, /a/));
assert.throws(makeBlock(deepEqual, /a/igm, /a/im));
assert(deepEqual(/a/, /a/));
assert(deepEqual(/a/g, /a/g));
assert(deepEqual(/a/i, /a/i));
assert(deepEqual(/a/m, /a/m));
assert(deepEqual(/a/igm, /a/igm));
assert(!deepEqual(/ab/, /a/));
assert(!deepEqual(/a/g, /a/));
assert(!deepEqual(/a/i, /a/));
assert(!deepEqual(/a/m, /a/));
assert(!deepEqual(/a/igm, /a/im));

var re1 = /a/;
re1.lastIndex = 3;
assert.throws(makeBlock(deepEqual, re1, /a/));
assert(!deepEqual(re1, /a/));
});


it('7.4', function () {
assert.doesNotThrow(makeBlock(deepEqual, 4, '4'), 'deepEqual(4, \'4\')');
assert.doesNotThrow(makeBlock(deepEqual, true, 1), 'deepEqual(true, 1)');
assert.throws(makeBlock(deepEqual, 4, '5'),
assert.AssertionError,
'deepEqual( 4, \'5\')');
assert(deepEqual(4, '4'), 'deepEqual(4, \'4\')');
assert(deepEqual(true, 1), 'deepEqual(true, 1)');
assert(!deepEqual(4, '5'), 'deepEqual( 4, \'5\')');
});


it('7.5', function () {
// having the same number of owned properties && the same set of keys
assert.doesNotThrow(makeBlock(deepEqual, {a: 4}, {a: 4}));
assert.doesNotThrow(makeBlock(deepEqual, {a: 4, b: '2'}, {a: 4, b: '2'}));
assert.doesNotThrow(makeBlock(deepEqual, [4], ['4']));
assert.throws(makeBlock(deepEqual, {a: 4}, {a: 4, b: true}),
assert.AssertionError);
assert.doesNotThrow(makeBlock(deepEqual, ['a'], {0: 'a'}));
assert(deepEqual({a: 4}, {a: 4}));
assert(deepEqual({a: 4, b: '2'}, {a: 4, b: '2'}));
assert(deepEqual([4], ['4']));
assert(!deepEqual({a: 4}, {a: 4, b: true}));
assert(deepEqual(['a'], {0: 'a'}));
//(although not necessarily the same order),
assert.doesNotThrow(makeBlock(deepEqual, {a: 4, b: '1'}, {b: '1', a: 4}));
assert(deepEqual({a: 4, b: '1'}, {b: '1', a: 4}));
var a1 = [1, 2, 3];
var a2 = [1, 2, 3];
a1.a = 'test';
a1.b = true;
a2.b = true;
a2.a = 'test';
assert.throws(makeBlock(deepEqual, keys(a1), keys(a2)),
assert.AssertionError);
assert.doesNotThrow(makeBlock(deepEqual, a1, a2));
assert(!deepEqual(keys(a1), keys(a2)));
assert(deepEqual(a1, a2));
});

it('having an identical prototype property', function () {
Expand All @@ -101,24 +83,25 @@ nameBuilder2.prototype = nbRoot;
var nb1 = new nameBuilder('Ryan', 'Dahl');
var nb2 = new nameBuilder2('Ryan', 'Dahl');

assert.doesNotThrow(makeBlock(deepEqual, nb1, nb2));
assert(deepEqual(nb1, nb2));

nameBuilder2.prototype = Object;
nb2 = new nameBuilder2('Ryan', 'Dahl');
assert.doesNotThrow(makeBlock(deepEqual, nb1, nb2));
assert(deepEqual(nb1, nb2));
});

it('primitives and object', function () {
assert.throws(makeBlock(deepEqual, null, {}), assert.AssertionError);
assert.throws(makeBlock(deepEqual, undefined, {}), assert.AssertionError);
assert.throws(makeBlock(deepEqual, 'a', ['a']), assert.AssertionError);
assert.throws(makeBlock(deepEqual, 'a', {0: 'a'}), assert.AssertionError);
assert.throws(makeBlock(deepEqual, 1, {}), assert.AssertionError);
assert.throws(makeBlock(deepEqual, true, {}), assert.AssertionError);
assert(!deepEqual(null, {}));
assert(!deepEqual(undefined, {}));
assert(!deepEqual('a', ['a']));
assert(!deepEqual('a', {0: 'a'}));
assert(!deepEqual(1, {}));
assert(!deepEqual(true, {}));
if (typeof Symbol !== 'undefined') {
assert.throws(makeBlock(deepEqual, Symbol(), {}), assert.AssertionError);
assert(!deepEqual(Symbol(), {}));
}
});

// https://github.com/nodejs/node/issues/6416
it("Make sure circular refs don't throw", function(){
var b = {};
Expand All @@ -127,8 +110,8 @@ b.b = b;
var c = {};
c.b = c;

assert.doesNotThrow(makeBlock(deepEqual, b, c));
assert.doesNotThrow(makeBlock(deepEqual, b, c));
assert(deepEqual(b, c));
assert(deepEqual(b, c));

var d = {};
d.a = 1;
Expand All @@ -138,36 +121,30 @@ var e = {};
e.a = 1;
e.b = e.a;

assert.throws(makeBlock(deepEqual, d, e), /AssertionError/);
assert.throws(makeBlock(deepEqual, d, e), /AssertionError/);
assert(!deepEqual(d, e));
assert(!deepEqual(d, e));
});

describe('primitive wrappers and object', function () {
it('String and array', function () {
if (new String('a')['0'] === 'a') {
assert.doesNotThrow(makeBlock(deepEqual, new String('a'), ['a']),
assert.AssertionError);
assert(deepEqual(new String('a'), ['a']));
} else {
assert.throws(makeBlock(deepEqual, new String('a'), ['a']),
assert.AssertionError);
assert(!deepEqual(new String('a'), ['a']));
}
});
it('String and object', function () {
if (new String('a')['0'] === 'a') {
assert.doesNotThrow(makeBlock(deepEqual, new String('a'), {0: 'a'}),
assert.AssertionError);
assert(deepEqual(new String('a'), {0: 'a'}));
} else {
assert.throws(makeBlock(deepEqual, new String('a'), {0: 'a'}),
assert.AssertionError);
assert(!deepEqual(new String('a'), {0: 'a'}));
}
});
it('Number', function () {
assert.doesNotThrow(makeBlock(deepEqual, new Number(1), {}),
assert.AssertionError);
assert(deepEqual(new Number(1), {}));
});
it('Boolean', function () {
assert.doesNotThrow(makeBlock(deepEqual, new Boolean(true), {}),
assert.AssertionError);
assert(deepEqual(new Boolean(true), {}));
});
});

Expand Down
Loading