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. 87
      lib/assert.js
  2. 61
      test/mjsunit/test-assert.js

87
lib/assert.js
View File

@ -41,6 +41,7 @@ assert.AssertionError = function AssertionError(options) {
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 //v8 specific
if (Error.captureStackTrace) { if (Error.captureStackTrace) {
Error.captureStackTrace(this, fail); Error.captureStackTrace(this, fail);
@ -58,10 +59,15 @@ assert.AssertionError = function AssertionError(options) {
}; };
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
@ -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,25 +113,23 @@ 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) {
@ -136,14 +139,12 @@ function _deepEqual(actual, expected) {
// 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' } else if (typeof actual != 'object' && typeof expected != 'object') {
&& typeof expected != 'object') {
return actual == expected; return actual == expected;
// 7.4. For all other Object pairs, including Array objects, equivalence is // 7.4. For all other Object pairs, including Array objects, equivalence is
@ -212,44 +213,30 @@ function objEquiv (a, b) {
// 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,
assert.throws = function(block, /*optional*/error, /*optional*/message){
var args = [true]
_throws.apply(this, args.concat(pSlice.call(arguments)));
}
// EXTENSION! This is annoying to write outside this module.
assert.doesNotThrow = function(block, /*optional*/error, /*optional*/message){
var args = [false]
_throws.apply(this, args.concat(pSlice.call(arguments)));
}
var _throws = function (shouldThrow, block, err, message) {
var exception = null
threw = false
typematters = true; typematters = true;
message = message || ""; message = message || "";
//handle optional arguments //handle optional arguments
@ -270,17 +257,31 @@ var _throws = function (shouldThrow, block, err, message) {
} }
if (shouldThrow && !threw) { if (shouldThrow && !threw) {
fail("Missing expected exception"+ fail( "Missing expected exception"
(err && err.name ? " ("+err.name+")." : '.') + + (err && err.name ? " ("+err.name+")." : '.')
(message ? " " + message : "")); + (message ? " " + message : "")
);
} }
if (!shouldThrow && threw && typematters && exception instanceof err) { if (!shouldThrow && threw && typematters && exception instanceof err) {
fail("Got unwanted exception" + fail( "Got unwanted exception"
(err && err.name ? " ("+err.name+")." : '.') + + (err && err.name ? " ("+err.name+")." : '.')
(message ? " " + message : "")); + (message ? " " + message : "")
);
} }
if ((shouldThrow && threw && typematters && !(exception instanceof err)) || if ((shouldThrow && threw && typematters && !(exception instanceof err)) ||
(!shouldThrow && threw)) { (!shouldThrow && threw)) {
throw exception; throw exception;
} }
}
// 11. Expected to throw an error:
// assert.throws(block, Error_opt, message_opt);
assert.throws = function(block, /*optional*/error, /*optional*/message) {
_throws.apply(this, [true].concat(pSlice.call(arguments)));
};
// EXTENSION! This is annoying to write outside this module.
assert.doesNotThrow = function(block, /*optional*/error, /*optional*/message) {
_throws.apply(this, [false].concat(pSlice.call(arguments)));
}; };

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

@ -1,46 +1,63 @@
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.doesNotThrow(makeBlock(a.ok, true),
a.AssertionError, "ok(true)");
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.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');
assert.throws(makeBlock(a.deepEqual, new Date(), new Date(2000,3,14)),
a.AssertionError,
'deepEqual date');
// 7.3 // 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"),
a.AssertionError,
'deepEqual == check');
// 7.4 // 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}));
@ -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){
function nameBuilder (first,last) {
this.first = first; this.first = first;
this.last = last; this.last = last;
return this; return this;
} }
nameBuilder.prototype = nbRoot; nameBuilder.prototype = nbRoot;
var nameBuilder2 = function(first,last){
function nameBuilder2 (first,last) {
this.first = first; this.first = first;
this.last = last; this.last = last;
return this; 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');
@ -93,12 +116,15 @@ function thrower(errorConstructor){
} }
aethrow = makeBlock(thrower, a.AssertionError); aethrow = makeBlock(thrower, a.AssertionError);
aethrow = makeBlock(thrower, a.AssertionError); aethrow = makeBlock(thrower, a.AssertionError);
// the basic calls work // the basic calls work
assert.throws(makeBlock(thrower, a.AssertionError), a.AssertionError, 'message'); assert.throws(makeBlock(thrower, a.AssertionError), a.AssertionError, 'message');
assert.throws(makeBlock(thrower, a.AssertionError), a.AssertionError); assert.throws(makeBlock(thrower, a.AssertionError), a.AssertionError);
assert.throws(makeBlock(thrower, a.AssertionError)); assert.throws(makeBlock(thrower, a.AssertionError));
// if not passing an error, catch all. // if not passing an error, catch all.
assert.throws(makeBlock(thrower, TypeError)); assert.throws(makeBlock(thrower, TypeError));
// when passing a type, only catch errors of the appropriate type // when passing a type, only catch errors of the appropriate type
var threw = false; var threw = false;
try { try {
@ -109,6 +135,7 @@ try{
} }
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 // doesNotThrow should pass through all errors
try { try {
a.doesNotThrow(makeBlock(thrower, TypeError), a.AssertionError); a.doesNotThrow(makeBlock(thrower, TypeError), a.AssertionError);
@ -117,7 +144,8 @@ try{
assert.ok(e instanceof TypeError); 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
// key difference is that throwing our correct error makes an assertion error
try { try {
a.doesNotThrow(makeBlock(thrower, TypeError), TypeError); a.doesNotThrow(makeBlock(thrower, TypeError), TypeError);
} catch(e) { } catch(e) {
@ -125,3 +153,4 @@ try{
assert.ok(e instanceof a.AssertionError); 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