08-27-周三_17-09-29

node_modules/traverse/test/equal.js

@@ -0,0 +1,238 @@
+'use strict';
+
+var test = require('tape');
+var deepEqual = require('./lib/deep_equal');
+
+test('deepDates', function (t) {
+	t.plan(2);
+
+	t.ok(
+		deepEqual(
+			{ d: new Date(), x: [1, 2, 3] },
+			{ d: new Date(), x: [1, 2, 3] }
+		),
+		'dates should be equal'
+	);
+
+	var d0 = new Date();
+	setTimeout(function () {
+		t.ok(
+			!deepEqual(
+				{ d: d0, x: [1, 2, 3] },
+				{ d: new Date(), x: [1, 2, 3] }
+			),
+			'microseconds should count in date equality'
+		);
+	}, 5);
+});
+
+test('deepCircular', function (t) {
+	var a = [1];
+	a.push(a); // a = [ 1, *a ]
+
+	var b = [1];
+	b.push(a); // b = [ 1, [ 1, *a ] ]
+
+	t.ok(
+		!deepEqual(a, b),
+		'circular ref mount points count towards equality'
+	);
+
+	var c = [1];
+	c.push(c); // c = [ 1, *c ]
+	t.ok(
+		deepEqual(a, c),
+		'circular refs are structurally the same here'
+	);
+
+	var d = [1];
+	d.push(a); // c = [ 1, [ 1, *d ] ]
+	t.ok(
+		deepEqual(b, d),
+		'non-root circular ref structural comparison'
+	);
+
+	t.end();
+});
+
+test('deepInstances', function (t) {
+	t.ok(
+		!deepEqual([Object(false)], [false]),
+		'boolean instances are not real booleans'
+	);
+
+	t.ok(
+		!deepEqual([Object('x')], ['x']),
+		'string instances are not real strings'
+	);
+
+	t.ok(
+		!deepEqual([Object(4)], [4]),
+		'number instances are not real numbers'
+	);
+
+	t.ok(
+		deepEqual([new RegExp('x')], [/x/]),
+		'regexp instances are real regexps'
+	);
+
+	t.ok(
+		!deepEqual([new RegExp(/./)], [/../]),
+		'these regexps aren\'t the same'
+	);
+
+	t.ok(
+		!deepEqual(
+			[function (x) { return x * 2; }],
+			[function (x) { return x * 2; }]
+		),
+		'functions with the same .toString() aren\'t necessarily the same'
+	);
+
+	function f(x) { return x * 2; }
+	t.ok(
+		deepEqual([f], [f]),
+		'these functions are actually equal'
+	);
+
+	t.end();
+});
+
+test('deepEqual', function (t) {
+	t.ok(
+		!deepEqual([1, 2, 3], { 0: 1, 1: 2, 2: 3 }),
+		'arrays are not objects'
+	);
+	t.end();
+});
+
+test('falsy', function (t) {
+	t.ok(
+		!deepEqual([undefined], [null]),
+		'null is not undefined!'
+	);
+
+	t.ok(
+		!deepEqual([null], [undefined]),
+		'undefined is not null!'
+	);
+
+	t.ok(
+		!deepEqual(
+			{ a: 1, b: 2, c: [3, undefined, 5] },
+			{ a: 1, b: 2, c: [3, null, 5] }
+		),
+		'undefined is not null, however deeply!'
+	);
+
+	t.ok(
+		!deepEqual(
+			{ a: 1, b: 2, c: [3, undefined, 5] },
+			{ a: 1, b: 2, c: [3, null, 5] }
+		),
+		'null is not undefined, however deeply!'
+	);
+
+	t.ok(
+		!deepEqual(
+			{ a: 1, b: 2, c: [3, undefined, 5] },
+			{ a: 1, b: 2, c: [3, null, 5] }
+		),
+		'null is not undefined, however deeply!'
+	);
+
+	t.end();
+});
+
+test('deletedArrayEqual', function (t) {
+	var xs = [1, 2, 3, 4];
+	delete xs[2];
+
+	var ys = Object.create(Array.prototype);
+	ys[0] = 1;
+	ys[1] = 2;
+	ys[3] = 4;
+
+	t.ok(
+		deepEqual(xs, ys),
+		'arrays with deleted elements are only equal to arrays with similarly deleted elements'
+	);
+
+	t.ok(
+		!deepEqual(xs, [1, 2, undefined, 4]),
+		'deleted array elements cannot be undefined'
+	);
+
+	t.ok(
+		!deepEqual(xs, [1, 2, null, 4]),
+		'deleted array elements cannot be null'
+	);
+
+	t.end();
+});
+
+test('deletedObjectEqual', function (t) {
+	var obj = { a: 1, b: 2, c: 3 };
+	delete obj.c;
+
+	t.ok(
+		deepEqual(obj, { a: 1, b: 2 }),
+		'deleted object elements should not show up'
+	);
+
+	t.ok(
+		!deepEqual(obj, { a: 1, b: 2, c: undefined }),
+		'deleted object elements are not undefined'
+	);
+
+	t.ok(
+		!deepEqual(obj, { a: 1, b: 2, c: null }),
+		'deleted object elements are not null'
+	);
+
+	t.end();
+});
+
+test('emptyKeyEqual', function (t) {
+	t.ok(!deepEqual({ a: 1 }, { a: 1, '': 55 }));
+
+	t.end();
+});
+
+test('deepArguments', function (t) {
+	t.ok(
+		!deepEqual(
+			[4, 5, 6],
+			(function () { return arguments; }(4, 5, 6))
+		),
+		'arguments are not arrays'
+	);
+
+	t.ok(
+		deepEqual(
+			(function () { return arguments; }(4, 5, 6)),
+			(function () { return arguments; }(4, 5, 6))
+		),
+		'arguments should equal'
+	);
+
+	t.end();
+});
+
+test('deepUn', function (t) {
+	t.ok(!deepEqual({ a: 1, b: 2 }, undefined));
+	t.ok(!deepEqual({ a: 1, b: 2 }, {}));
+	t.ok(!deepEqual(undefined, { a: 1, b: 2 }));
+	t.ok(!deepEqual({}, { a: 1, b: 2 }));
+	t.ok(deepEqual(undefined, undefined));
+	t.ok(deepEqual(null, null));
+	t.ok(!deepEqual(undefined, null));
+
+	t.end();
+});
+
+test('deepLevels', function (t) {
+	var xs = [1, 2, [3, 4, [5, 6]]];
+	t.ok(!deepEqual(xs, []));
+	t.end();
+});