dojo-util
Version:
Dojo utilities including build system for optimizing JavaScript application performance, and DOH testing tool
275 lines (241 loc) • 9.41 kB
JavaScript
define(["doh/runner"], function(doh) {
doh.register("doh/selftest/lastTest", function(t){
t.assertTrue(true);
});
var
tObj1 = { a:0, b:1, c:true, d:false, e:{}, f:{a:"x"}, g:"", h:"hellp", i:null},
tObj2 = { a:0, b:1, c:true, d:false, e:{}, f:{a:"x"}, g:"", h:"hellp", i:null}, // equal
tObja = { a:1, b:1, c:true, d:false, e:{}, f:{a:"x"}, g:"", h:"hellp", i:null}, // delta a
tObjb = { a:0, b:2, c:true, d:false, e:{}, f:{a:"x"}, g:"", h:"hellp", i:null}, // delta b
tObjc = { a:0, b:1, c:false, d:false, e:{}, f:{a:"x"}, g:"", h:"hellp", i:null}, // delta c
tObjd = { a:0, b:1, c:true, d:true, e:{}, f:{a:"x"}, g:"", h:"hellp", i:null}, // delta d
tObje = { a:0, b:1, c:true, d:false, e:{a:"x"}, f:{a:"x"}, g:"", h:"hellp", i:null}, // delta e
tObjf1= { a:0, b:1, c:true, d:false, e:{}, f:{a:"y"}, g:"", h:"hellp", i:null}, // delta f.a
tObjf2= { a:0, b:1, c:true, d:false, e:{}, f:{b:"x"}, g:"", h:"hellp", i:null}, // delta f, property
tObjg = { a:0, b:1, c:true, d:false, e:{}, f:{}, g:"x", h:"hellp", i:null}, // delta g
tObjh = { a:0, b:1, c:true, d:false, e:{}, f:{}, g:"", h:"hello", i:null}, // delta h
tObji = { a:0, b:1, c:true, d:false, e:{}, f:{}, g:"", h:"hellp", i:0}, // delta i
tArray1 = [0, 1, true, false, {}, {a:"x"}, "", "hello", null],
tArray2 = [0, 1, true, false, {}, {a:"x"}, "", "hello", null],
tArraya = [1, 1, true, false, {}, {a:"x"}, "", "hellp", null], // delta a
tArrayb = [0, 2, true, false, {}, {a:"x"}, "", "hellp", null], // delta b
tArrayc = [0, 1, false, false, {}, {a:"x"}, "", "hellp", null], // delta c
tArrayd = [0, 1, true, true, {}, {a:"x"}, "", "hellp", null], // delta d
tArraye = [0, 1, true, false, {a:"x"}, {a:"x"}, "", "hellp", null], // delta e
tArrayf1= [0, 1, true, false, {}, {a:"y"}, "", "hellp", null], // delta f.a
tArrayf2= [0, 1, true, false, {}, {b:"x"}, "", "hellp", null], // delta f, property
tArrayg = [0, 1, true, false, {}, {}, "x", "hellp", null], // delta g
tArrayh = [0, 1, true, false, {}, {}, "", "hello", null], // delta h
tArrayi = [0, 1, true, false, {}, {}, "", "hellp", 0]; // delta i
doh.register("doh/asserts/pass", function(t){
function check(method, args){
t[method].apply(t, args);
};
check("assertTrue", [true]);
check("assertTrue", [{}]);
check("assertTrue", [1]);
//check("assertTrue", ["hello"]);
check("assertFalse", [false]);
check("assertFalse", [0]);
check("assertFalse", [null]);
check("assertFalse", [undefined]);
check("assertFalse", [(function(){})()]);
check("assertEqual", [[], []]);
check("assertEqual", [[1], [1]]);
check("assertEqual", [[1,2], [1,2]]);
check("assertEqual", [[1,2,3], [1,2,3]]);
check("assertEqual", [tObj1, tObj1]);
check("assertEqual", [tObj1, tObj2]);
check("assertEqual", [tArray1, tArray2]);
check("assertNotEqual", [tObj1, tObja]);
check("assertNotEqual", [tObj1, tObjb]);
check("assertNotEqual", [tObj1, tObjc]);
check("assertNotEqual", [tObj1, tObjd]);
check("assertNotEqual", [tObj1, tObje]);
check("assertNotEqual", [tObj1, tObjf1]);
check("assertNotEqual", [tObj1, tObjf2]);
check("assertNotEqual", [tObj1, tObjg]);
check("assertNotEqual", [tObj1, tObjh]);
check("assertNotEqual", [tObj1, tObji]);
check("assertNotEqual", [tArray1, tArraya]);
check("assertNotEqual", [tArray1, tArrayb]);
check("assertNotEqual", [tArray1, tArrayc]);
check("assertNotEqual", [tArray1, tArrayd]);
check("assertNotEqual", [tArray1, tArraye]);
check("assertNotEqual", [tArray1, tArrayf1]);
check("assertNotEqual", [tArray1, tArrayf2]);
check("assertNotEqual", [tArray1, tArrayg]);
check("assertNotEqual", [tArray1, tArrayh]);
check("assertNotEqual", [tArray1, tArrayi]);
});
doh.register("doh/asserts/fail", function(t){
function check(method, args){
try{
t[method].apply(t, args);
}catch(e){
t.assertTrue(true);
return;
}
throw new doh._AssertFailure("failed: " + method);
}
check("assertFalse", [true]);
check("assertFalse", [{}]);
check("assertFalse", [1]);
//check("assertFalse", ["hello"]);
check("assertTrue", [false]);
check("assertTrue", [0]);
check("assertTrue", [null]);
check("assertTrue", [undefined]);
check("assertTrue", [(function(){})()]);
check("assertNotEqual", [[], []]);
check("assertNotEqual", [[1], [1]]);
check("assertNotEqual", [[1,2], [1,2]]);
check("assertNotEqual", [[1,2,3], [1,2,3]]);
check("assertNotEqual", [tObj1, tObj1]);
check("assertNotEqual", [tObj1, tObj2]);
check("assertNotEqual", [tArray1, tArray2]);
check("assertEqual", [tObj1, tObja]);
check("assertEqual", [tObj1, tObjb]);
check("assertEqual", [tObj1, tObjc]);
check("assertEqual", [tObj1, tObjd]);
check("assertEqual", [tObj1, tObje]);
check("assertEqual", [tObj1, tObjf1]);
check("assertEqual", [tObj1, tObjf2]);
check("assertEqual", [tObj1, tObjg]);
check("assertEqual", [tObj1, tObjh]);
check("assertEqual", [tObj1, tObji]);
check("assertEqual", [tArray1, tArraya]);
check("assertEqual", [tArray1, tArrayb]);
check("assertEqual", [tArray1, tArrayc]);
check("assertEqual", [tArray1, tArrayd]);
check("assertEqual", [tArray1, tArraye]);
check("assertEqual", [tArray1, tArrayf1]);
check("assertEqual", [tArray1, tArrayf2]);
check("assertEqual", [tArray1, tArrayg]);
check("assertEqual", [tArray1, tArrayh]);
check("assertEqual", [tArray1, tArrayi]);
});
// test the highly overloaded doh.register signature
var currentFixture;
dojo.connect(doh, "_testStarted", function(groupId, fixture){
currentFixture= fixture;
});
var lastId;
function f(id, tid) {
return function() {
if(tid){
doh.assertTrue(currentFixture.name==tid);
}
if(id){
doh.assertTrue(lastId+1==id);
lastId= id;
}
};
};
var hijack= doh._setupGroupForRun;
doh._setupGroupForRun= function(groupName){
lastId= 0;
hijack.call(doh, groupName);
};
// note: the tests that are commented out below all have zero for the setup function
// and a real teardown function. For now, this is
doh.register("myGroup2-1", f(2), f(1), f(3));
doh.register("myGroup2-2", f(2), f(1));
doh.register("myGroup2-4", f(1));
dohSelfTestLog5= f(2);
dohSelfTestLog6= f(2);
dohSelfTestLog7= f(1);
dohSelfTestLog8= f(1);
doh.register("myGroup2-5", "dohSelfTestLog5();", f(1), f(3));
doh.register("myGroup2-6", "dohSelfTestLog6();", f(1));
doh.register("myGroup2-8", "dohSelfTestLog8();");
doh.register("myGroup2-9", [f(2), f(3)], f(1), f(4));
doh.register("myGroup2-10", [f(2), f(3)], f(1));
doh.register("myGroup2-12", [f(1), f(2)]);
doh.register("myGroup2-13", {t1:f(0, "t1"), t2:f(0, "t2")}, f(1), f(2));
doh.register("myGroup2-14", {t3:f(0, "t3"), t4:f(0, "t4")}, f(1));
doh.register("myGroup2-16", {t7:f(0, "t7"), t8:f(0, "t8")});
doh.register("myGroup2-17", {name:"t9", runTest:f(2, "t9")}, f(1), f(3));
doh.register("myGroup2-18", {name:"t10", runTest:f(2, "t10")}, f(1));
doh.register("myGroup2-20", {name:"t12", runTest:f(1, "t12")});
doh.register("myGroup2-21", {name:"tx", runTest:f(3), setUp:f(2)}, f(1), f(4));
doh.register("myGroup2-22", {name:"tx", runTest:f(3), setUp:f(2)}, f(1));
doh.register("myGroup2-24", {name:"tx", runTest:f(2), setUp:f(1)});
doh.register("myGroup2-25", {name:"tx", runTest:f(2), tearDown:f(3)}, f(1), f(4));
doh.register("myGroup2-26", {name:"tx", runTest:f(2), tearDown:f(3)}, f(1));
doh.register("myGroup2-28", {name:"tx", runTest:f(1), tearDown:f(2)});
doh.register("myGroup2-29", {name:"tx", runTest:f(3), setUp:f(2), tearDown:f(4)}, f(1), f(5));
doh.register("myGroup2-30", {name:"tx", runTest:f(3), setUp:f(2), tearDown:f(4)}, f(1));
doh.register("myGroup2-32", {name:"tx", runTest:f(2), setUp:f(1), tearDown:f(3)});
//v1.6- signatures
//TODO
doh.registerTestType("dohSelfTest", function(group, fixture){
});
// a stone-stupid async test
doh.register("doh/async", [{
name: "doh.Deferred success",
runTest: function(t){
var d = new doh.Deferred();
setTimeout(d.getTestCallback(function(){
t.assertTrue(true);
t.assertFalse(false);
}), 50);
return d;
}
},{
name: "dojo.Deferred success",
runTest: function(t){
var d = new dojo.Deferred();
setTimeout(function(){
d.resolve(true);
}, 50);
return d;
}
},{
name: "doh.Deferred failure--SHOULD FAIL",
runTest: function(t){
console.log("running test that SHOULD FAIL");
var d = new doh.Deferred();
setTimeout(d.getTestCallback(function(){
t.assertTrue(false);
}), 50);
return d;
}
},{
name: "dojo.Deferred failure--SHOULD FAIL",
runTest: function(t){
console.log("running test that SHOULD FAIL");
var d = new dojo.Deferred();
setTimeout(function(){
d.reject(new Error("hrm..."));
}, 50);
return d;
}
},{
name: "doh.Deferred timeout failure--SHOULD FAIL",
timeout: 50,
runTest: function(t){
console.log("running test that SHOULD FAIL");
// timeout of 50
var d = new doh.Deferred();
setTimeout(d.getTestCallback(function(){
}), 100);
return d;
}
},{
name: "dojo.Deferred timeout failure--SHOULD FAIL",
timeout: 50,
runTest: function(t){
console.log("running test that SHOULD FAIL");
// timeout of 50
var d = new dojo.Deferred();
setTimeout(function(){
d.callback(true);
}, 100);
return d;
}
}]);
doh.register("doh/selftest/lastTest", function(t){
t.assertTrue(true);
});
});