Skip to content
This repository has been archived by the owner on Apr 22, 2023. It is now read-only.

Commit

Permalink
Fix assert.js code style
Browse files Browse the repository at this point in the history
  • Loading branch information
@ry
ry committed Dec 29, 2009
1 parent 0d7e88a commit dd35637
Show file tree
Hide file tree
Showing 2 changed files with 247 additions and 217 deletions.
311 changes: 156 additions & 155 deletions lib/assert.js
View file
Original file line number Original file line Diff line number Diff line change
Expand Up @@ -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
Expand All @@ -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.
Expand All @@ -99,188 +105,183 @@ 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
// ==. // ==.
// 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;
}
}; };
Loading

0 comments on commit dd35637

Please sign in to comment.