mirror of https://github.com/lukechilds/node.git
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
127 lines
4.7 KiB
127 lines
4.7 KiB
process.mixin(require("./common"));
|
|
|
|
//strangely meta, no?
|
|
|
|
var a = require('assert');
|
|
|
|
|
|
function makeBlock(f){
|
|
var args = Array.prototype.slice.call(arguments,1);
|
|
return function(){
|
|
return f.apply(this,args);
|
|
}
|
|
}
|
|
|
|
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.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, 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.4
|
|
// 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;}
|
|
}
|
|
var nameBuilder = function(first,last){
|
|
this.first = first;
|
|
this.last = last;
|
|
return this;
|
|
}
|
|
nameBuilder.prototype = nbRoot;
|
|
var nameBuilder2 = function(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');
|
|
}
|
|
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');
|
|
//the 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');
|
|
|