lukechilds
/
node
mirror of https://github.com/lukechilds/node.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Fix assert.js code style

v0.7.4-release
Ryan Dahl 15 years ago
parent
0d7e88a429
commit
dd35637603
2 changed files with 247 additions and 217 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 311
      lib/assert.js
  2. 153
      test/mjsunit/test-assert.js

311
lib/assert.js
View File

@ -36,32 +36,38 @@ var assert = exports;
// new assert.AssertionError({message: message, actual: actual, expected: expected}) // new assert.AssertionError({message: message, actual: actual, expected: expected})
assert.AssertionError = function AssertionError(options) { assert.AssertionError = function AssertionError(options) {
this.name = "AssertionError"; this.name = "AssertionError";
this.message = options.message; this.message = options.message;
this.actual = options.actual; this.actual = options.actual;
this.expected = options.expected; this.expected = options.expected;
this.operator = options.operator; this.operator = options.operator;
//v8 specific
if(Error.captureStackTrace){ //v8 specific
Error.captureStackTrace(this,fail); if (Error.captureStackTrace) {
//node specific, removes the node machinery stack frames Error.captureStackTrace(this, fail);
if(typeof(__filename) !== undefined){ //node specific, removes the node machinery stack frames
var stack = this.stack.split('\n'); if (typeof(__filename) !== undefined) {
for (var i = stack.length - 1; i >= 0; i--) { var stack = this.stack.split('\n');
if(stack[i].indexOf(__filename) != -1){ for (var i = stack.length - 1; i >= 0; i--) {
this.stack = stack.slice(0,i+2).join('\n'); if (stack[i].indexOf(__filename) != -1) {
break; this.stack = stack.slice(0, i+2).join('\n');
} break;
}
} }
}
} }
}
}; };
assert.AssertionError.prototype.toString = function(){ assert.AssertionError.prototype.toString = function() {
if(this.message) if (this.message) {
return [this.name+":", this.message].join(' '); return [this.name+":", this.message].join(' ');
else } else {
return [this.name+":", JSON.stringify(this.expected ), this.operator , JSON.stringify(this.actual)].join(" "); return [ this.name+":"
, JSON.stringify(this.expected )
, this.operator
, JSON.stringify(this.actual)
].join(" ");
}
} }
// assert.AssertionError instanceof Error // assert.AssertionError instanceof Error
@ -80,12 +86,12 @@ assert.AssertionError.__proto__ = Error.prototype;
// display purposes. // display purposes.
function fail(actual, expected, message, operator) { function fail(actual, expected, message, operator) {
throw new assert.AssertionError({ throw new assert.AssertionError({
message: message, message: message,
actual: actual, actual: actual,
expected: expected, expected: expected,
operator: operator operator: operator
}); });
} }
// EXTENSION! allows for well behaved errors defined elsewhere. // EXTENSION! allows for well behaved errors defined elsewhere.
@ -99,8 +105,7 @@ assert.fail = fail;
// assert.strictEqual(true, guard, message_opt);. // assert.strictEqual(true, guard, message_opt);.
assert.ok = function ok(value, message) { assert.ok = function ok(value, message) {
if (!!!value) if (!!!value) fail(value, true, message, "==");
fail(value, true, message, "==");
}; };
// 5. The equality assertion tests shallow, coercive equality with // 5. The equality assertion tests shallow, coercive equality with
@ -108,179 +113,175 @@ assert.ok = function ok(value, message) {
// assert.equal(actual, expected, message_opt); // assert.equal(actual, expected, message_opt);
assert.equal = function equal(actual, expected, message) { assert.equal = function equal(actual, expected, message) {
if (actual != expected) if (actual != expected) fail(actual, expected, message, "==");
fail(actual, expected, message, "==");
}; };
// 6. The non-equality assertion tests for whether two objects are not equal // 6. The non-equality assertion tests for whether two objects are not equal
// with != assert.notEqual(actual, expected, message_opt); // with != assert.notEqual(actual, expected, message_opt);
assert.notEqual = function notEqual(actual, expected, message) { assert.notEqual = function notEqual(actual, expected, message) {
if (actual == expected) if (actual == expected) fail(actual, expected, message, "!=");
fail(actual, expected, message, "!=");
}; };
// 7. The equivalence assertion tests a deep equality relation. // 7. The equivalence assertion tests a deep equality relation.
// assert.deepEqual(actual, expected, message_opt); // assert.deepEqual(actual, expected, message_opt);
exports.deepEqual = function deepEqual(actual, expected, message) { exports.deepEqual = function deepEqual(actual, expected, message) {
if (!_deepEqual(actual, expected)) if (!_deepEqual(actual, expected)) {
fail(actual, expected, message, "deepEqual"); fail(actual, expected, message, "deepEqual");
}
}; };
function _deepEqual(actual, expected) { function _deepEqual(actual, expected) {
// 7.1. All identical values are equivalent, as determined by ===. // 7.1. All identical values are equivalent, as determined by ===.
if (actual === expected) { if (actual === expected) {
return true; return true;
// 7.2. If the expected value is a Date object, the actual value is // 7.2. If the expected value is a Date object, the actual value is
// equivalent if it is also a Date object that refers to the same time. // equivalent if it is also a Date object that refers to the same time.
} else if (actual instanceof Date } else if (actual instanceof Date && expected instanceof Date) {
&& expected instanceof Date) { return actual.getTime() === expected.getTime();
return actual.getTime() === expected.getTime();
// 7.3. Other pairs that do not both pass typeof value == "object",
// 7.3. Other pairs that do not both pass typeof value == "object", // equivalence is determined by ==.
// equivalence is determined by ==. } else if (typeof actual != 'object' && typeof expected != 'object') {
} else if (typeof actual != 'object' return actual == expected;
&& typeof expected != 'object') {
return actual == expected; // 7.4. For all other Object pairs, including Array objects, equivalence is
// determined by having the same number of owned properties (as verified
// 7.4. For all other Object pairs, including Array objects, equivalence is // with Object.prototype.hasOwnProperty.call), the same set of keys
// determined by having the same number of owned properties (as verified // (although not necessarily the same order), equivalent values for every
// with Object.prototype.hasOwnProperty.call), the same set of keys // corresponding key, and an identical "prototype" property. Note: this
// (although not necessarily the same order), equivalent values for every // accounts for both named and indexed properties on Arrays.
// corresponding key, and an identical "prototype" property. Note: this } else {
// accounts for both named and indexed properties on Arrays. return objEquiv(actual, expected);
} else { }
return objEquiv(actual, expected);
}
} }
function isUndefinedOrNull (value) { function isUndefinedOrNull (value) {
return value === null || value === undefined; return value === null || value === undefined;
} }
function isArguments (object){ function isArguments (object) {
return Object.prototype.toString.call(object) == '[object Arguments]'; return Object.prototype.toString.call(object) == '[object Arguments]';
} }
function objEquiv (a, b) { function objEquiv (a, b) {
if (isUndefinedOrNull(a) || isUndefinedOrNull(b)) if (isUndefinedOrNull(a) || isUndefinedOrNull(b))
return false; return false;
// an identical "prototype" property. // an identical "prototype" property.
if (a.prototype !== b.prototype) return false; if (a.prototype !== b.prototype) return false;
//~~~I've managed to break Object.keys through screwy arguments passing. //~~~I've managed to break Object.keys through screwy arguments passing.
// Converting to array solves the problem. // Converting to array solves the problem.
if(isArguments(a)){ if (isArguments(a)) {
if(!isArguments(b)){ if (!isArguments(b)) {
return false; return false;
}
a = pSlice.call(a);
b = pSlice.call(b);
return _deepEqual(a,b);
}
try{
var ka = Object.keys(a),
kb = Object.keys(b),
key, i;
} catch (e) {//happens when one is a string literal and the other isn't
return false;
} }
// having the same number of owned properties (keys incorporates hasOwnProperty) a = pSlice.call(a);
if(ka.length != kb.length) b = pSlice.call(b);
return false; return _deepEqual(a, b);
//the same set of keys (although not necessarily the same order), }
ka.sort(); try{
kb.sort(); var ka = Object.keys(a),
//~~~cheap key test kb = Object.keys(b),
for (i = ka.length - 1; i >= 0; i--) { key, i;
if(ka[i] != kb[i]) } catch (e) {//happens when one is a string literal and the other isn't
return false; return false;
} }
//equivalent values for every corresponding key, and // having the same number of owned properties (keys incorporates hasOwnProperty)
//~~~possibly expensive deep test if (ka.length != kb.length)
for (i = ka.length - 1; i >= 0; i--) { return false;
key = ka[i]; //the same set of keys (although not necessarily the same order),
if(!_deepEqual(a[key], b[key] )) ka.sort();
return false; kb.sort();
} //~~~cheap key test
return true; for (i = ka.length - 1; i >= 0; i--) {
if (ka[i] != kb[i])
return false;
}
//equivalent values for every corresponding key, and
//~~~possibly expensive deep test
for (i = ka.length - 1; i >= 0; i--) {
key = ka[i];
if (!_deepEqual(a[key], b[key] ))
return false;
}
return true;
} }
// 8. The non-equivalence assertion tests for any deep inequality. // 8. The non-equivalence assertion tests for any deep inequality.
// assert.notDeepEqual(actual, expected, message_opt); // assert.notDeepEqual(actual, expected, message_opt);
exports.notDeepEqual = function notDeepEqual(actual, expected, message) { exports.notDeepEqual = function notDeepEqual(actual, expected, message) {
if (_deepEqual(actual, expected)) if (_deepEqual(actual, expected)) {
fail(actual, expected, message, "notDeepEqual"); fail(actual, expected, message, "notDeepEqual");
}
}; };
// 9. The strict equality assertion tests strict equality, as determined by ===. // 9. The strict equality assertion tests strict equality, as determined by ===.
// assert.strictEqual(actual, expected, message_opt); // assert.strictEqual(actual, expected, message_opt);
assert.strictEqual = function strictEqual(actual, expected, message) { assert.strictEqual = function strictEqual(actual, expected, message) {
if (actual !== expected) if (actual !== expected) fail(actual, expected, message, "===");
fail(actual, expected, message, "===");
}; };
// 10. The strict non-equality assertion tests for strict inequality, as determined by !==. // 10. The strict non-equality assertion tests for strict inequality, as determined by !==.
// assert.notStrictEqual(actual, expected, message_opt); // assert.notStrictEqual(actual, expected, message_opt);
assert.notStrictEqual = function notStrictEqual(actual, expected, message) { assert.notStrictEqual = function notStrictEqual(actual, expected, message) {
if (actual === expected) if (actual === expected) fail(actual, expected, message, "!==");
fail(actual, expected, message, "!==");
}; };
// 11. Expected to throw an error: function _throws (shouldThrow, block, err, message) {
// assert.throws(block, Error_opt, message_opt); var exception = null,
threw = false,
typematters = true;
assert.throws = function(block, /*optional*/error, /*optional*/message){ message = message || "";
var args = [true]
_throws.apply(this, args.concat(pSlice.call(arguments)));
}
// EXTENSION! This is annoying to write outside this module. //handle optional arguments
assert.doesNotThrow = function(block, /*optional*/error, /*optional*/message){ if (arguments.length == 3) {
var args = [false] if (typeof(err) == "string") {
_throws.apply(this, args.concat(pSlice.call(arguments))); message = err;
typematters = false;
}
} else if (arguments.length == 2) {
typematters = false;
}
try {
block();
} catch (e) {
threw = true;
exception = e;
}
if (shouldThrow && !threw) {
fail( "Missing expected exception"
+ (err && err.name ? " ("+err.name+")." : '.')
+ (message ? " " + message : "")
);
}
if (!shouldThrow && threw && typematters && exception instanceof err) {
fail( "Got unwanted exception"
+ (err && err.name ? " ("+err.name+")." : '.')
+ (message ? " " + message : "")
);
}
if ((shouldThrow && threw && typematters && !(exception instanceof err)) ||
(!shouldThrow && threw)) {
throw exception;
}
} }
var _throws = function (shouldThrow, block, err, message) { // 11. Expected to throw an error:
var exception = null // assert.throws(block, Error_opt, message_opt);
threw = false
typematters = true;
message = message || "";
//handle optional arguments
if(arguments.length == 3){
if(typeof(err) == "string"){
message = err;
typematters = false;
}
} else if(arguments.length == 2) {
typematters = false;
}
try { assert.throws = function(block, /*optional*/error, /*optional*/message) {
block(); _throws.apply(this, [true].concat(pSlice.call(arguments)));
} catch (e) { };
threw = true;
exception = e;
}
if(shouldThrow && !threw){ // EXTENSION! This is annoying to write outside this module.
fail("Missing expected exception"+ assert.doesNotThrow = function(block, /*optional*/error, /*optional*/message) {
(err && err.name ? " ("+err.name+")." : '.') + _throws.apply(this, [false].concat(pSlice.call(arguments)));
(message ? " " + message : ""));
}
if(!shouldThrow && threw && typematters && exception instanceof err){
fail("Got unwanted exception" +
(err && err.name ? " ("+err.name+")." : '.') +
(message ? " " + message : ""));
}
if((shouldThrow && threw && typematters && !(exception instanceof err)) ||
(!shouldThrow && threw)){
throw exception;
}
}; };

153
test/mjsunit/test-assert.js
View File

@ -1,52 +1,69 @@
process.mixin(require("./common")); process.mixin(require("./common"));
//strangely meta, no?
var a = require('assert'); var a = require('assert');
function makeBlock (f) {
function makeBlock(f){ var args = Array.prototype.slice.call(arguments,1);
var args = Array.prototype.slice.call(arguments,1); return function () {
return function(){ return f.apply(this,args);
return f.apply(this,args); };
}
} }
assert.ok(a.AssertionError instanceof Error, "a.AssertionError instanceof Error"); assert.ok(a.AssertionError instanceof Error,
"a.AssertionError instanceof Error");
assert.throws(makeBlock(a.ok, false),
a.AssertionError, "ok(false)");
assert.throws(makeBlock(a.ok, false), a.AssertionError, "ok(false)"); assert.doesNotThrow(makeBlock(a.ok, true),
assert.doesNotThrow(makeBlock(a.ok, true), a.AssertionError, "ok(true)"); a.AssertionError, "ok(true)");
assert.doesNotThrow(makeBlock(a.ok, "test"),"ok('test')");
assert.doesNotThrow(makeBlock(a.ok, "test"), "ok('test')");
assert.throws(makeBlock(a.equal, true, false), a.AssertionError, 'equal'); assert.throws(makeBlock(a.equal, true, false), a.AssertionError, 'equal');
assert.doesNotThrow(makeBlock(a.equal, null, null), 'equal'); assert.doesNotThrow(makeBlock(a.equal, null, null), 'equal');
assert.doesNotThrow(makeBlock(a.equal, undefined, undefined), 'equal'); assert.doesNotThrow(makeBlock(a.equal, undefined, undefined), 'equal');
assert.doesNotThrow(makeBlock(a.equal, null, undefined), 'equal'); assert.doesNotThrow(makeBlock(a.equal, null, undefined), 'equal');
assert.doesNotThrow(makeBlock(a.equal, true, true), 'equal'); assert.doesNotThrow(makeBlock(a.equal, true, true), 'equal');
assert.doesNotThrow(makeBlock(a.equal, 2, "2"), 'equal'); assert.doesNotThrow(makeBlock(a.equal, 2, "2"), 'equal');
assert.doesNotThrow(makeBlock(a.notEqual, true, false), 'notEqual'); assert.doesNotThrow(makeBlock(a.notEqual, true, false), 'notEqual');
assert.throws(makeBlock(a.notEqual, true, true), a.AssertionError, '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, 2, "2"), a.AssertionError, 'strictEqual');
assert.throws(makeBlock(a.strictEqual, null, undefined), a.AssertionError, 'strictEqual'); assert.throws(makeBlock(a.strictEqual, null, undefined), a.AssertionError, 'strictEqual');
assert.doesNotThrow(makeBlock(a.notStrictEqual, 2, "2"), 'notStrictEqual'); assert.doesNotThrow(makeBlock(a.notStrictEqual, 2, "2"), 'notStrictEqual');
//deepEquals joy! // deepEquals joy!
//7.2 // 7.2
assert.doesNotThrow(makeBlock(a.deepEqual, new Date(2000,3,14), new Date(2000,3,14)), 'deepEqual date'); assert.doesNotThrow(makeBlock(a.deepEqual, new Date(2000,3,14), new Date(2000,3,14)),
assert.throws( makeBlock(a.deepEqual, new Date(), new Date(2000,3,14)), a.AssertionError, 'deepEqual date'); 'deepEqual date');
//7.3
assert.throws(makeBlock(a.deepEqual, new Date(), new Date(2000,3,14)),
a.AssertionError,
'deepEqual date');
// 7.3
assert.doesNotThrow(makeBlock(a.deepEqual, 4, "4"), 'deepEqual == check'); assert.doesNotThrow(makeBlock(a.deepEqual, 4, "4"), 'deepEqual == check');
assert.doesNotThrow(makeBlock(a.deepEqual, true, 1), 'deepEqual == check'); assert.doesNotThrow(makeBlock(a.deepEqual, true, 1), 'deepEqual == check');
assert.throws( makeBlock(a.deepEqual, 4, "5"), a.AssertionError, 'deepEqual == check'); assert.throws(makeBlock(a.deepEqual, 4, "5"),
//7.4 a.AssertionError,
'deepEqual == check');
// 7.4
// having the same number of owned properties && the same set of keys // 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}, {a:4}));
assert.doesNotThrow(makeBlock(a.deepEqual, {a:4,b:"2"}, {a:4,b:"2"})); assert.doesNotThrow(makeBlock(a.deepEqual, {a:4,b:"2"}, {a:4,b:"2"}));
assert.doesNotThrow(makeBlock(a.deepEqual, [4], ["4"])); assert.doesNotThrow(makeBlock(a.deepEqual, [4], ["4"]));
assert.throws( makeBlock(a.deepEqual, {a:4}, {a:4,b:true}), a.AssertionError); assert.throws(makeBlock(a.deepEqual, {a:4}, {a:4,b:true}), a.AssertionError);
assert.doesNotThrow(makeBlock(a.deepEqual, ["a"], {0:"a"})); assert.doesNotThrow(makeBlock(a.deepEqual, ["a"], {0:"a"}));
//(although not necessarily the same order), //(although not necessarily the same order),
assert.doesNotThrow(makeBlock(a.deepEqual, {a:4,b:"1"}, {b:"1",a:4})); assert.doesNotThrow(makeBlock(a.deepEqual, {a:4,b:"1"}, {b:"1",a:4}));
@ -55,26 +72,32 @@ var a2 = [1,2,3];
a1.a = "test"; a1.a = "test";
a1.b = true; a1.b = true;
a2.b = true; a2.b = true;
a2.a = "test" a2.a = "test";
assert.throws( makeBlock(a.deepEqual, Object.keys(a1), Object.keys(a2)), a.AssertionError); assert.throws(makeBlock(a.deepEqual,
Object.keys(a1),
Object.keys(a2)),
a.AssertionError);
assert.doesNotThrow(makeBlock(a.deepEqual, a1, a2)); assert.doesNotThrow(makeBlock(a.deepEqual, a1, a2));
// having an identical prototype property // having an identical prototype property
var nbRoot = { var nbRoot = {
toString: function(){return this.first+' '+this.last;} toString: function () { return this.first+' '+this.last; }
} };
var nameBuilder = function(first,last){
this.first = first; function nameBuilder (first,last) {
this.last = last; this.first = first;
return this; this.last = last;
return this;
} }
nameBuilder.prototype = nbRoot; nameBuilder.prototype = nbRoot;
var nameBuilder2 = function(first,last){
this.first = first; function nameBuilder2 (first,last) {
this.last = last; this.first = first;
return this; this.last = last;
return this;
} }
nameBuilder2.prototype = nbRoot; nameBuilder2.prototype = nbRoot;
var nb1 = new nameBuilder('Ryan', 'Dahl'); var nb1 = new nameBuilder('Ryan', 'Dahl');
var nb2 = new nameBuilder2('Ryan','Dahl'); var nb2 = new nameBuilder2('Ryan','Dahl');
@ -82,46 +105,52 @@ assert.doesNotThrow(makeBlock(a.deepEqual, nb1, nb2));
nameBuilder2.prototype = Object; nameBuilder2.prototype = Object;
nb2 = new nameBuilder2('Ryan','Dahl'); nb2 = new nameBuilder2('Ryan','Dahl');
assert.throws( makeBlock(a.deepEqual, nb1, nb2), a.AssertionError); assert.throws(makeBlock(a.deepEqual, nb1, nb2), a.AssertionError);
//String literal + object blew up my implementation... // String literal + object blew up my implementation...
assert.throws( makeBlock(a.deepEqual, 'a', {}), a.AssertionError); assert.throws(makeBlock(a.deepEqual, 'a', {}), a.AssertionError);
//Testing the throwing // Testing the throwing
function thrower(errorConstructor){ function thrower (errorConstructor){
throw new errorConstructor('test'); throw new errorConstructor('test');
} }
aethrow = makeBlock(thrower, a.AssertionError); aethrow = makeBlock(thrower, a.AssertionError);
aethrow = makeBlock(thrower, a.AssertionError); aethrow = makeBlock(thrower, a.AssertionError);
//the basic calls work
assert.throws( makeBlock(thrower, a.AssertionError), a.AssertionError, 'message'); // the basic calls work
assert.throws( makeBlock(thrower, a.AssertionError), a.AssertionError); assert.throws(makeBlock(thrower, a.AssertionError), a.AssertionError, 'message');
assert.throws( makeBlock(thrower, a.AssertionError)); assert.throws(makeBlock(thrower, a.AssertionError), a.AssertionError);
//if not passing an error, catch all. assert.throws(makeBlock(thrower, a.AssertionError));
assert.throws( makeBlock(thrower, TypeError));
//when passing a type, only catch errors of the appropriate type // 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; var threw = false;
try{ try {
a.throws( makeBlock(thrower, TypeError), a.AssertionError); a.throws(makeBlock(thrower, TypeError), a.AssertionError);
}catch (e){ } catch (e) {
threw = true; threw = true;
assert.ok(e instanceof TypeError, 'type'); assert.ok(e instanceof TypeError, 'type');
} }
assert.equal(true,threw,'a.throws with an explicit error is eating extra errors', a.AssertionError); assert.equal(true,threw,'a.throws with an explicit error is eating extra errors', a.AssertionError);
threw = false; threw = false;
//doesNotThrow should pass through all errors
try{ // doesNotThrow should pass through all errors
a.doesNotThrow(makeBlock(thrower, TypeError), a.AssertionError); try {
}catch(e){ a.doesNotThrow(makeBlock(thrower, TypeError), a.AssertionError);
threw = true } catch(e) {
assert.ok(e instanceof TypeError); threw = true
assert.ok(e instanceof TypeError);
} }
assert.equal(true,threw,'a.doesNotThrow with an explicit error is eating extra errors'); assert.equal(true,threw,'a.doesNotThrow with an explicit error is eating extra errors');
//the key difference is that throwing our correct error makes an assertion error
try{ // key difference is that throwing our correct error makes an assertion error
a.doesNotThrow(makeBlock(thrower, TypeError), TypeError); try {
}catch(e){ a.doesNotThrow(makeBlock(thrower, TypeError), TypeError);
threw = true } catch(e) {
assert.ok(e instanceof a.AssertionError); threw = true
assert.ok(e instanceof a.AssertionError);
} }
assert.equal(true,threw,'a.doesNotThrow is not catching type matching errors'); assert.equal(true,threw,'a.doesNotThrow is not catching type matching errors');

Write Preview
Loading…
Cancel
Save