mirror of
https://github.com/nodejs/node.git
synced 2024-11-30 07:27:22 +01:00
6101eb184d
4716dc6
made assert.equal() and related functions work better by
generating a better toString() from the expected, actual, and operator
values passed to fail(). Unfortunately, this was accomplished by putting
the generated message into the error's `name` property. When you passed
in a custom error message, the error would put the custom error into
`name` *and* `message`, resulting in helpful string representations like
"AssertionError: Oh no: Oh no".
This commit resolves that issue by storing the generated message in the
`message` property while leaving the error's name alone and adding
a regression test so that this doesn't pop back up later.
Closes #5292.
309 lines
9.3 KiB
JavaScript
309 lines
9.3 KiB
JavaScript
// Copyright Joyent, Inc. and other Node contributors.
|
|
//
|
|
// Permission is hereby granted, free of charge, to any person obtaining a
|
|
// copy of this software and associated documentation files (the
|
|
// "Software"), to deal in the Software without restriction, including
|
|
// without limitation the rights to use, copy, modify, merge, publish,
|
|
// distribute, sublicense, and/or sell copies of the Software, and to permit
|
|
// persons to whom the Software is furnished to do so, subject to the
|
|
// following conditions:
|
|
//
|
|
// The above copyright notice and this permission notice shall be included
|
|
// in all copies or substantial portions of the Software.
|
|
//
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
|
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
|
|
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
|
|
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
|
|
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
|
|
// USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
|
|
var common = require('../common');
|
|
var assert = require('assert');
|
|
var a = require('assert');
|
|
|
|
function makeBlock(f) {
|
|
var args = Array.prototype.slice.call(arguments, 1);
|
|
return function() {
|
|
return f.apply(this, args);
|
|
};
|
|
}
|
|
|
|
assert.ok(common.indirectInstanceOf(a.AssertionError.prototype, Error),
|
|
'a.AssertionError instanceof Error');
|
|
|
|
assert.throws(makeBlock(a, false), a.AssertionError, 'ok(false)');
|
|
|
|
assert.doesNotThrow(makeBlock(a, true), a.AssertionError, 'ok(true)');
|
|
|
|
assert.doesNotThrow(makeBlock(a, 'test', 'ok(\'test\')'));
|
|
|
|
assert.throws(makeBlock(a.ok, false),
|
|
a.AssertionError, 'ok(false)');
|
|
|
|
assert.doesNotThrow(makeBlock(a.ok, true),
|
|
a.AssertionError, 'ok(true)');
|
|
|
|
assert.doesNotThrow(makeBlock(a.ok, 'test'), 'ok(\'test\')');
|
|
|
|
assert.throws(makeBlock(a.equal, true, false), a.AssertionError, 'equal');
|
|
|
|
assert.doesNotThrow(makeBlock(a.equal, null, null), 'equal');
|
|
|
|
assert.doesNotThrow(makeBlock(a.equal, undefined, undefined), 'equal');
|
|
|
|
assert.doesNotThrow(makeBlock(a.equal, null, undefined), 'equal');
|
|
|
|
assert.doesNotThrow(makeBlock(a.equal, true, true), 'equal');
|
|
|
|
assert.doesNotThrow(makeBlock(a.equal, 2, '2'), 'equal');
|
|
|
|
assert.doesNotThrow(makeBlock(a.notEqual, true, false), 'notEqual');
|
|
|
|
assert.throws(makeBlock(a.notEqual, true, true),
|
|
a.AssertionError, 'notEqual');
|
|
|
|
assert.throws(makeBlock(a.strictEqual, 2, '2'),
|
|
a.AssertionError, 'strictEqual');
|
|
|
|
assert.throws(makeBlock(a.strictEqual, null, undefined),
|
|
a.AssertionError, 'strictEqual');
|
|
|
|
assert.doesNotThrow(makeBlock(a.notStrictEqual, 2, '2'), 'notStrictEqual');
|
|
|
|
// deepEquals joy!
|
|
// 7.2
|
|
assert.doesNotThrow(makeBlock(a.deepEqual, new Date(2000, 3, 14),
|
|
new Date(2000, 3, 14)), 'deepEqual date');
|
|
|
|
assert.throws(makeBlock(a.deepEqual, new Date(), new Date(2000, 3, 14)),
|
|
a.AssertionError,
|
|
'deepEqual date');
|
|
|
|
// 7.3
|
|
assert.doesNotThrow(makeBlock(a.deepEqual, /a/, /a/));
|
|
assert.doesNotThrow(makeBlock(a.deepEqual, /a/g, /a/g));
|
|
assert.doesNotThrow(makeBlock(a.deepEqual, /a/i, /a/i));
|
|
assert.doesNotThrow(makeBlock(a.deepEqual, /a/m, /a/m));
|
|
assert.doesNotThrow(makeBlock(a.deepEqual, /a/igm, /a/igm));
|
|
assert.throws(makeBlock(a.deepEqual, /ab/, /a/));
|
|
assert.throws(makeBlock(a.deepEqual, /a/g, /a/));
|
|
assert.throws(makeBlock(a.deepEqual, /a/i, /a/));
|
|
assert.throws(makeBlock(a.deepEqual, /a/m, /a/));
|
|
assert.throws(makeBlock(a.deepEqual, /a/igm, /a/im));
|
|
|
|
var re1 = /a/;
|
|
re1.lastIndex = 3;
|
|
assert.throws(makeBlock(a.deepEqual, re1, /a/));
|
|
|
|
|
|
// 7.4
|
|
assert.doesNotThrow(makeBlock(a.deepEqual, 4, '4'), 'deepEqual == check');
|
|
assert.doesNotThrow(makeBlock(a.deepEqual, true, 1), 'deepEqual == check');
|
|
assert.throws(makeBlock(a.deepEqual, 4, '5'),
|
|
a.AssertionError,
|
|
'deepEqual == check');
|
|
|
|
// 7.5
|
|
// having the same number of owned properties && the same set of keys
|
|
assert.doesNotThrow(makeBlock(a.deepEqual, {a: 4}, {a: 4}));
|
|
assert.doesNotThrow(makeBlock(a.deepEqual, {a: 4, b: '2'}, {a: 4, b: '2'}));
|
|
assert.doesNotThrow(makeBlock(a.deepEqual, [4], ['4']));
|
|
assert.throws(makeBlock(a.deepEqual, {a: 4}, {a: 4, b: true}),
|
|
a.AssertionError);
|
|
assert.doesNotThrow(makeBlock(a.deepEqual, ['a'], {0: 'a'}));
|
|
//(although not necessarily the same order),
|
|
assert.doesNotThrow(makeBlock(a.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(a.deepEqual, Object.keys(a1), Object.keys(a2)),
|
|
a.AssertionError);
|
|
assert.doesNotThrow(makeBlock(a.deepEqual, a1, a2));
|
|
|
|
// having an identical prototype property
|
|
var nbRoot = {
|
|
toString: function() { return this.first + ' ' + this.last; }
|
|
};
|
|
|
|
function nameBuilder(first, last) {
|
|
this.first = first;
|
|
this.last = last;
|
|
return this;
|
|
}
|
|
nameBuilder.prototype = nbRoot;
|
|
|
|
function nameBuilder2(first, last) {
|
|
this.first = first;
|
|
this.last = last;
|
|
return this;
|
|
}
|
|
nameBuilder2.prototype = nbRoot;
|
|
|
|
var nb1 = new nameBuilder('Ryan', 'Dahl');
|
|
var nb2 = new nameBuilder2('Ryan', 'Dahl');
|
|
|
|
assert.doesNotThrow(makeBlock(a.deepEqual, nb1, nb2));
|
|
|
|
nameBuilder2.prototype = Object;
|
|
nb2 = new nameBuilder2('Ryan', 'Dahl');
|
|
assert.throws(makeBlock(a.deepEqual, nb1, nb2), a.AssertionError);
|
|
|
|
// String literal + object blew up my implementation...
|
|
assert.throws(makeBlock(a.deepEqual, 'a', {}), a.AssertionError);
|
|
|
|
// Testing the throwing
|
|
function thrower(errorConstructor) {
|
|
throw new errorConstructor('test');
|
|
}
|
|
var aethrow = makeBlock(thrower, a.AssertionError);
|
|
aethrow = makeBlock(thrower, a.AssertionError);
|
|
|
|
// the basic calls work
|
|
assert.throws(makeBlock(thrower, a.AssertionError),
|
|
a.AssertionError, 'message');
|
|
assert.throws(makeBlock(thrower, a.AssertionError), a.AssertionError);
|
|
assert.throws(makeBlock(thrower, a.AssertionError));
|
|
|
|
// if not passing an error, catch all.
|
|
assert.throws(makeBlock(thrower, TypeError));
|
|
|
|
// when passing a type, only catch errors of the appropriate type
|
|
var threw = false;
|
|
try {
|
|
a.throws(makeBlock(thrower, TypeError), a.AssertionError);
|
|
} catch (e) {
|
|
threw = true;
|
|
assert.ok(e instanceof TypeError, 'type');
|
|
}
|
|
assert.equal(true, threw,
|
|
'a.throws with an explicit error is eating extra errors',
|
|
a.AssertionError);
|
|
threw = false;
|
|
|
|
// doesNotThrow should pass through all errors
|
|
try {
|
|
a.doesNotThrow(makeBlock(thrower, TypeError), a.AssertionError);
|
|
} catch (e) {
|
|
threw = true;
|
|
assert.ok(e instanceof TypeError);
|
|
}
|
|
assert.equal(true, threw,
|
|
'a.doesNotThrow with an explicit error is eating extra errors');
|
|
|
|
// key difference is that throwing our correct error makes an assertion error
|
|
try {
|
|
a.doesNotThrow(makeBlock(thrower, TypeError), TypeError);
|
|
} catch (e) {
|
|
threw = true;
|
|
assert.ok(e instanceof a.AssertionError);
|
|
}
|
|
assert.equal(true, threw,
|
|
'a.doesNotThrow is not catching type matching errors');
|
|
|
|
assert.throws(function() {assert.ifError(new Error('test error'))});
|
|
assert.doesNotThrow(function() {assert.ifError(null)});
|
|
assert.doesNotThrow(function() {assert.ifError()});
|
|
|
|
// make sure that validating using constructor really works
|
|
threw = false;
|
|
try {
|
|
assert.throws(
|
|
function() {
|
|
throw ({});
|
|
},
|
|
Array
|
|
);
|
|
} catch (e) {
|
|
threw = true;
|
|
}
|
|
assert.ok(threw, 'wrong constructor validation');
|
|
|
|
// use a RegExp to validate error message
|
|
a.throws(makeBlock(thrower, TypeError), /test/);
|
|
|
|
// use a fn to validate error object
|
|
a.throws(makeBlock(thrower, TypeError), function(err) {
|
|
if ((err instanceof TypeError) && /test/.test(err)) {
|
|
return true;
|
|
}
|
|
});
|
|
|
|
|
|
// GH-207. Make sure deepEqual doesn't loop forever on circular refs
|
|
|
|
var b = {};
|
|
b.b = b;
|
|
|
|
var c = {};
|
|
c.b = c;
|
|
|
|
var gotError = false;
|
|
try {
|
|
assert.deepEqual(b, c);
|
|
} catch (e) {
|
|
gotError = true;
|
|
}
|
|
|
|
console.log('All OK');
|
|
assert.ok(gotError);
|
|
|
|
|
|
// #217
|
|
function testAssertionMessage(actual, expected) {
|
|
try {
|
|
assert.equal(actual, '');
|
|
} catch (e) {
|
|
assert.equal(e.toString(),
|
|
['AssertionError:', expected, '==', '""'].join(' '));
|
|
}
|
|
}
|
|
testAssertionMessage(undefined, '"undefined"');
|
|
testAssertionMessage(null, 'null');
|
|
testAssertionMessage(true, 'true');
|
|
testAssertionMessage(false, 'false');
|
|
testAssertionMessage(0, '0');
|
|
testAssertionMessage(100, '100');
|
|
testAssertionMessage(NaN, '"NaN"');
|
|
testAssertionMessage(Infinity, '"Infinity"');
|
|
testAssertionMessage(-Infinity, '"-Infinity"');
|
|
testAssertionMessage('', '""');
|
|
testAssertionMessage('foo', '"foo"');
|
|
testAssertionMessage([], '[]');
|
|
testAssertionMessage([1, 2, 3], '[1,2,3]');
|
|
testAssertionMessage(/a/, '"/a/"');
|
|
testAssertionMessage(/abc/gim, '"/abc/gim"');
|
|
testAssertionMessage(function f() {}, '"function f() {}"');
|
|
testAssertionMessage({}, '{}');
|
|
testAssertionMessage({a: undefined, b: null}, '{"a":"undefined","b":null}');
|
|
testAssertionMessage({a: NaN, b: Infinity, c: -Infinity},
|
|
'{"a":"NaN","b":"Infinity","c":"-Infinity"}');
|
|
|
|
// #2893
|
|
try {
|
|
assert.throws(function () {
|
|
assert.ifError(null);
|
|
});
|
|
} catch (e) {
|
|
threw = true;
|
|
assert.equal(e.message, 'Missing expected exception..');
|
|
}
|
|
assert.ok(threw);
|
|
|
|
// #5292
|
|
try {
|
|
assert.equal(1, 2);
|
|
} catch (e) {
|
|
assert.equal(e.toString().split('\n')[0], 'AssertionError: 1 == 2')
|
|
}
|
|
|
|
try {
|
|
assert.equal(1, 2, 'oh no');
|
|
} catch (e) {
|
|
assert.equal(e.toString().split('\n')[0], 'AssertionError: oh no')
|
|
}
|