Lea/web-apps
1
0
Fork 0
Code Issues Pull requests Packages Projects Releases Wiki Activity
web-apps/vendor/requirejs/tests/doh/runner.js

1500 lines
44 KiB
JavaScript
Raw Normal View History

webapps added
2016-03-11 00:48:53 +00:00
// package system gunk.
//try{
// dojo.provide("doh.runner");
//}catch(e){
if(!this["doh"]){
doh = {};
}
//}
//
// Utility Functions and Classes
//
doh.selfTest = false;
doh.global = this;
doh.hitch = function(/*Object*/thisObject, /*Function|String*/method /*, ...*/){
var args = [];
for(var x=2; x<arguments.length; x++){
args.push(arguments[x]);
}
var fcn = ((typeof method == "string") ? thisObject[method] : method) || function(){};
return function(){
var ta = args.concat([]); // make a copy
for(var x=0; x<arguments.length; x++){
ta.push(arguments[x]);
}
return fcn.apply(thisObject, ta); // Function
};
}
doh._mixin = function(/*Object*/ obj, /*Object*/ props){
// summary:
// Adds all properties and methods of props to obj. This addition is
// "prototype extension safe", so that instances of objects will not
// pass along prototype defaults.
var tobj = {};
for(var x in props){
// the "tobj" condition avoid copying properties in "props"
// inherited from Object.prototype. For example, if obj has a custom
// toString() method, don't overwrite it with the toString() method
// that props inherited from Object.protoype
if(tobj[x] === undefined || tobj[x] != props[x]){
obj[x] = props[x];
}
}
// IE doesn't recognize custom toStrings in for..in
if( this["document"]
&& document.all
&& (typeof props["toString"] == "function")
&& (props["toString"] != obj["toString"])
&& (props["toString"] != tobj["toString"])
){
obj.toString = props.toString;
}
return obj; // Object
}
doh.mixin = function(/*Object*/obj, /*Object...*/props){
// summary: Adds all properties and methods of props to obj.
for(var i=1, l=arguments.length; i<l; i++){
doh._mixin(obj, arguments[i]);
}
return obj; // Object
}
doh.extend = function(/*Object*/ constructor, /*Object...*/ props){
// summary:
// Adds all properties and methods of props to constructor's
// prototype, making them available to all instances created with
// constructor.
for(var i=1, l=arguments.length; i<l; i++){
doh._mixin(constructor.prototype, arguments[i]);
}
return constructor; // Object
}
doh._line = "------------------------------------------------------------";
/*
doh._delegate = function(obj, props){
// boodman-crockford delegation
function TMP(){};
TMP.prototype = obj;
var tmp = new TMP();
if(props){
dojo.lang.mixin(tmp, props);
}
return tmp;
}
*/
doh.debug = function(){
// summary:
// takes any number of arguments and sends them to whatever debugging
// or logging facility is available in this environment
// YOUR TEST RUNNER NEEDS TO IMPLEMENT THIS
}
doh._AssertFailure = function(msg, hint){
// idea for this as way of dis-ambiguating error types is from JUM.
// The JUM is dead! Long live the JUM!
if(!(this instanceof doh._AssertFailure)){
return new doh._AssertFailure(msg, hint);
}
if(hint){
msg = (new String(msg||""))+" with hint: \n\t\t"+(new String(hint)+"\n");
}
this.message = new String(msg||"");
return this;
}
doh._AssertFailure.prototype = new Error();
doh._AssertFailure.prototype.constructor = doh._AssertFailure;
doh._AssertFailure.prototype.name = "doh._AssertFailure";
doh.Deferred = function(canceller){
this.chain = [];
this.id = this._nextId();
this.fired = -1;
this.paused = 0;
this.results = [null, null];
this.canceller = canceller;
this.silentlyCancelled = false;
};
doh.extend(doh.Deferred, {
getTestErrback: function(cb, scope){
// summary: Replaces outer getTextCallback's in nested situations to avoid multiple callback(true)'s
var _this = this;
return function(){
try{
cb.apply(scope||doh.global||_this, arguments);
}catch(e){
_this.errback(e);
}
};
},
getTestCallback: function(cb, scope){
var _this = this;
return function(){
try{
cb.apply(scope||doh.global||_this, arguments);
}catch(e){
_this.errback(e);
return;
}
_this.callback(true);
};
},
getFunctionFromArgs: function(){
var a = arguments;
if((a[0])&&(!a[1])){
if(typeof a[0] == "function"){
return a[0];
}else if(typeof a[0] == "string"){
return doh.global[a[0]];
}
}else if((a[0])&&(a[1])){
return doh.hitch(a[0], a[1]);
}
return null;
},
makeCalled: function() {
var deferred = new doh.Deferred();
deferred.callback();
return deferred;
},
_nextId: (function(){
var n = 1;
return function(){ return n++; };
})(),
cancel: function(){
if(this.fired == -1){
if (this.canceller){
this.canceller(this);
}else{
this.silentlyCancelled = true;
}
if(this.fired == -1){
this.errback(new Error("Deferred(unfired)"));
}
}else if(this.fired == 0 &&
(this.results[0] instanceof doh.Deferred)){
this.results[0].cancel();
}
},
_pause: function(){
this.paused++;
},
_unpause: function(){
this.paused--;
if ((this.paused == 0) && (this.fired >= 0)) {
this._fire();
}
},
_continue: function(res){
this._resback(res);
this._unpause();
},
_resback: function(res){
this.fired = ((res instanceof Error) ? 1 : 0);
this.results[this.fired] = res;
this._fire();
},
_check: function(){
if(this.fired != -1){
if(!this.silentlyCancelled){
throw new Error("already called!");
}
this.silentlyCancelled = false;
return;
}
},
callback: function(res){
this._check();
this._resback(res);
},
errback: function(res){
this._check();
if(!(res instanceof Error)){
res = new Error(res);
}
this._resback(res);
},
addBoth: function(cb, cbfn){
var enclosed = this.getFunctionFromArgs(cb, cbfn);
if(arguments.length > 2){
enclosed = doh.hitch(null, enclosed, arguments, 2);
}
return this.addCallbacks(enclosed, enclosed);
},
addCallback: function(cb, cbfn){
var enclosed = this.getFunctionFromArgs(cb, cbfn);
if(arguments.length > 2){
enclosed = doh.hitch(null, enclosed, arguments, 2);
}
return this.addCallbacks(enclosed, null);
},
addErrback: function(cb, cbfn){
var enclosed = this.getFunctionFromArgs(cb, cbfn);
if(arguments.length > 2){
enclosed = doh.hitch(null, enclosed, arguments, 2);
}
return this.addCallbacks(null, enclosed);
},
addCallbacks: function(cb, eb){
this.chain.push([cb, eb]);
if(this.fired >= 0){
this._fire();
}
return this;
},
_fire: function(){
var chain = this.chain;
var fired = this.fired;
var res = this.results[fired];
var self = this;
var cb = null;
while(chain.length > 0 && this.paused == 0){
// Array
var pair = chain.shift();
var f = pair[fired];
if(f == null){
continue;
}
try {
res = f(res);
fired = ((res instanceof Error) ? 1 : 0);
if(res instanceof doh.Deferred){
cb = function(res){
self._continue(res);
};
this._pause();
}
}catch(err){
fired = 1;
res = err;
}
}
this.fired = fired;
this.results[fired] = res;
if((cb)&&(this.paused)){
res.addBoth(cb);
}
}
});
//
// State Keeping and Reporting
//
doh._testCount = 0;
doh._groupCount = 0;
doh._errorCount = 0;
doh._failureCount = 0;
doh._currentGroup = null;
doh._currentTest = null;
doh._paused = true;
doh._init = function(){
this._currentGroup = null;
this._currentTest = null;
this._errorCount = 0;
this._failureCount = 0;
this.debug(this._testCount, "tests to run in", this._groupCount, "groups");
}
// doh._urls = [];
doh._groups = {};
//
// Test Registration
//
doh.registerTestNs = function(/*String*/ group, /*Object*/ ns){
// summary:
// adds the passed namespace object to the list of objects to be
// searched for test groups. Only "public" functions (not prefixed
// with "_") will be added as tests to be run. If you'd like to use
// fixtures (setUp(), tearDown(), and runTest()), please use
// registerTest() or registerTests().
for(var x in ns){
if( (x.charAt(0) != "_") &&
(typeof ns[x] == "function") ){
this.registerTest(group, ns[x]);
}
}
}
doh._testRegistered = function(group, fixture){
// slot to be filled in
}
doh._groupStarted = function(group){
// slot to be filled in
}
doh._groupFinished = function(group, success){
// slot to be filled in
}
doh._testStarted = function(group, fixture){
// slot to be filled in
}
doh._testFinished = function(group, fixture, success){
// slot to be filled in
}
doh.registerGroup = function( /*String*/ group,
/*Array||Function||Object*/ tests,
/*Function*/ setUp,
/*Function*/ tearDown,
/*String*/ type){
// summary:
// registers an entire group of tests at once and provides a setUp and
// tearDown facility for groups. If you call this method with only
// setUp and tearDown parameters, they will replace previously
// installed setUp or tearDown functions for the group with the new
// methods.
// group:
// string name of the group
// tests:
// either a function or an object or an array of functions/objects. If
// an object, it must contain at *least* a "runTest" method, and may
// also contain "setUp" and "tearDown" methods. These will be invoked
// on either side of the "runTest" method (respectively) when the test
// is run. If an array, it must contain objects matching the above
// description or test functions.
// setUp: a function for initializing the test group
// tearDown: a function for initializing the test group
// type: The type of tests these are, such as a group of performance tests
// null/undefied are standard DOH tests, the valye 'perf' enables
// registering them as performance tests.
if(tests){
this.register(group, tests, type);
}
if(setUp){
this._groups[group].setUp = setUp;
}
if(tearDown){
this._groups[group].tearDown = tearDown;
}
}
doh._getTestObj = function(group, test, type){
var tObj = test;
if(typeof test == "string"){
if(test.substr(0, 4)=="url:"){
return this.registerUrl(group, test);
}else{
tObj = {
name: test.replace("/\s/g", "_") // FIXME: bad escapement
};
tObj.runTest = new Function("t", test);
}
}else if(typeof test == "function"){
// if we didn't get a fixture, wrap the function
tObj = { "runTest": test };
if(test["name"]){
tObj.name = test.name;
}else{
try{
var fStr = "function ";
var ts = tObj.runTest+"";
if(0 <= ts.indexOf(fStr)){
tObj.name = ts.split(fStr)[1].split("(", 1)[0];
}
// doh.debug(tObj.runTest.toSource());
}catch(e){
}
}
// FIXME: try harder to get the test name here
}
//Augment the test with some specific options to make it identifiable as a
//particular type of test so it can be executed properly.
if(type === "perf" || tObj.testType === "perf"){
tObj.testType = "perf";
//Build an object on the root DOH class to contain all the test results.
//Cache it on the test object for quick lookup later for results storage.
if(!doh.perfTestResults){
doh.perfTestResults = {};
doh.perfTestResults[group] = {};
}
if(!doh.perfTestResults[group]){
doh.perfTestResults[group] = {};
}
if(!doh.perfTestResults[group][tObj.name]){
doh.perfTestResults[group][tObj.name] = {};
}
tObj.results = doh.perfTestResults[group][tObj.name];
//If it's not set, then set the trial duration
//default to 100ms.
if(!("trialDuration" in tObj)){
tObj.trialDuration = 100;
}
//If it's not set, then set the delay between trial runs to 100ms
//default to 100ms to allow for GC and to make IE happy.
if(!("trialDelay" in tObj)){
tObj.trialDelay = 100;
}
//If it's not set, then set number of times a trial is run to 10.
if(!("trialIterations" in tObj)){
tObj.trialIterations = 10;
}
}
return tObj;
}
doh.registerTest = function(/*String*/ group, /*Function||Object*/ test, /*String*/ type){
// summary:
// add the provided test function or fixture object to the specified
// test group.
// group:
// string name of the group to add the test to
// test:
// either a function or an object. If an object, it must contain at
// *least* a "runTest" method, and may also contain "setUp" and
// "tearDown" methods. These will be invoked on either side of the
// "runTest" method (respectively) when the test is run.
// type:
// An identifier denoting the type of testing that the test performs, such
// as a performance test. If null, defaults to regular DOH test.
if(!this._groups[group]){
this._groupCount++;
this._groups[group] = [];
this._groups[group].inFlight = 0;
}
var tObj = this._getTestObj(group, test, type);
if(!tObj){ return null; }
this._groups[group].push(tObj);
this._testCount++;
this._testRegistered(group, tObj);
return tObj;
}
doh.registerTests = function(/*String*/ group, /*Array*/ testArr, /*String*/ type){
// summary:
// registers a group of tests, treating each element of testArr as
// though it were being (along with group) passed to the registerTest
// method. It also uses the type to decide how the tests should
// behave, by defining the type of tests these are, such as performance tests
for(var x=0; x<testArr.length; x++){
this.registerTest(group, testArr[x], type);
}
}
// FIXME: move implementation to _browserRunner?
doh.registerUrl = function( /*String*/ group,
/*String*/ url,
/*Integer*/ timeout,
/*String*/ type){
this.debug("ERROR:");
this.debug("\tNO registerUrl() METHOD AVAILABLE.");
// this._urls.push(url);
}
doh.registerString = function(group, str, type){
}
// FIXME: remove the doh.add alias SRTL.
doh.register = doh.add = function(groupOrNs, testOrNull, type){
// summary:
// "magical" variant of registerTests, registerTest, and
// registerTestNs. Will accept the calling arguments of any of these
// methods and will correctly guess the right one to register with.
if( (arguments.length == 1)&&
(typeof groupOrNs == "string") ){
if(groupOrNs.substr(0, 4)=="url:"){
this.registerUrl(groupOrNs, null, null, type);
}else{
this.registerTest("ungrouped", groupOrNs, type);
}
}
if(arguments.length == 1){
this.debug("invalid args passed to doh.register():", groupOrNs, ",", testOrNull);
return;
}
if(typeof testOrNull == "string"){
if(testOrNull.substr(0, 4)=="url:"){
this.registerUrl(testOrNull, null, null, type);
}else{
this.registerTest(groupOrNs, testOrNull, type);
}
// this.registerTestNs(groupOrNs, testOrNull);
return;
}
if(doh._isArray(testOrNull)){
this.registerTests(groupOrNs, testOrNull, type);
return;
}
this.registerTest(groupOrNs, testOrNull, type);
};
doh.registerDocTests = function(module){
// no-op for when Dojo isn't loaded into the page
this.debug("registerDocTests() requires dojo to be loaded into the environment. Skipping doctest set for module:", module);
};
(function(){
if(typeof dojo != "undefined"){
try{
dojo.require("dojox.testing.DocTest");
}catch(e){
// if the DocTest module isn't available (e.g., the build we're
// running from doesn't include it), stub it out and log the error
console.debug(e);
doh.registerDocTests = function(){}
return;
}
doh.registerDocTests = function(module){
// summary:
// Get all the doctests from the given module and register each of them
// as a single test case here.
//
var docTest = new dojox.testing.DocTest();
var docTests = docTest.getTests(module);
var len = docTests.length;
var tests = [];
for (var i=0; i<len; i++){
var test = docTests[i];
// Extract comment on first line and add to test name.
var comment = "";
if (test.commands.length && test.commands[0].indexOf("//")!=-1) {
var parts = test.commands[0].split("//");
comment = ", "+parts[parts.length-1]; // Get all after the last //, so we dont get trapped by http:// or alikes :-).
}
tests.push({
runTest: (function(test){
return function(t){
var r = docTest.runTest(test.commands, test.expectedResult);
t.assertTrue(r.success);
}
})(test),
name:"Line "+test.line+comment
}
);
}
this.register("DocTests: "+module, tests);
}
}
})();
//
// Assertions and In-Test Utilities
//
doh.t = doh.assertTrue = function(/*Object*/ condition, /*String?*/ hint){
// summary:
// is the passed item "truthy"?
if(arguments.length < 1){
throw new doh._AssertFailure("assertTrue failed because it was not passed at least 1 argument");
}
if(!eval(condition)){
throw new doh._AssertFailure("assertTrue('" + condition + "') failed", hint);
}
}
doh.f = doh.assertFalse = function(/*Object*/ condition, /*String?*/ hint){
// summary:
// is the passed item "falsey"?
if(arguments.length < 1){
throw new doh._AssertFailure("assertFalse failed because it was not passed at least 1 argument");
}
if(eval(condition)){
throw new doh._AssertFailure("assertFalse('" + condition + "') failed", hint);
}
}
doh.e = doh.assertError = function(/*Error object*/expectedError, /*Object*/scope, /*String*/functionName, /*Array*/args, /*String?*/ hint){
// summary:
// Test for a certain error to be thrown by the given function.
// example:
// t.assertError(dojox.data.QueryReadStore.InvalidAttributeError, store, "getValue", [item, "NOT THERE"]);
// t.assertError(dojox.data.QueryReadStore.InvalidItemError, store, "getValue", ["not an item", "NOT THERE"]);
try{
scope[functionName].apply(scope, args);
}catch (e){
if(e instanceof expectedError){
return true;
}else{
throw new doh._AssertFailure("assertError() failed:\n\texpected error\n\t\t"+expectedError+"\n\tbut got\n\t\t"+e+"\n\n", hint);
}
}
throw new doh._AssertFailure("assertError() failed:\n\texpected error\n\t\t"+expectedError+"\n\tbut no error caught\n\n", hint);
}
doh.is = doh.assertEqual = function(/*Object*/ expected, /*Object*/ actual, /*String?*/ hint){
// summary:
// are the passed expected and actual objects/values deeply
// equivalent?
// Compare undefined always with three equal signs, because undefined==null
// is true, but undefined===null is false.
if((expected === undefined)&&(actual === undefined)){
return true;
}
if(arguments.length < 2){
throw doh._AssertFailure("assertEqual failed because it was not passed 2 arguments");
}
if((expected === actual)||(expected == actual)||
( typeof expected == "number" && typeof actual == "number" && isNaN(expected) && isNaN(actual) )){
return true;
}
if( (this._isArray(expected) && this._isArray(actual))&&
(this._arrayEq(expected, actual)) ){
return true;
}
if( ((typeof expected == "object")&&((typeof actual == "object")))&&
(this._objPropEq(expected, actual)) ){
return true;
}
throw new doh._AssertFailure("assertEqual() failed:\n\texpected\n\t\t"+expected+"\n\tbut got\n\t\t"+actual+"\n\n", hint);
}
doh.isNot = doh.assertNotEqual = function(/*Object*/ notExpected, /*Object*/ actual, /*String?*/ hint){
// summary:
// are the passed notexpected and actual objects/values deeply
// not equivalent?
// Compare undefined always with three equal signs, because undefined==null
// is true, but undefined===null is false.
if((notExpected === undefined)&&(actual === undefined)){
throw new doh._AssertFailure("assertNotEqual() failed: not expected |"+notExpected+"| but got |"+actual+"|", hint);
}
if(arguments.length < 2){
throw doh._AssertFailure("assertEqual failed because it was not passed 2 arguments");
}
if((notExpected === actual)||(notExpected == actual)){
throw new doh._AssertFailure("assertNotEqual() failed: not expected |"+notExpected+"| but got |"+actual+"|", hint);
}
if( (this._isArray(notExpected) && this._isArray(actual))&&
(this._arrayEq(notExpected, actual)) ){
throw new doh._AssertFailure("assertNotEqual() failed: not expected |"+notExpected+"| but got |"+actual+"|", hint);
}
if( ((typeof notExpected == "object")&&((typeof actual == "object")))&&
(this._objPropEq(notExpected, actual)) ){
throw new doh._AssertFailure("assertNotEqual() failed: not expected |"+notExpected+"| but got |"+actual+"|", hint);
}
return true;
}
doh._arrayEq = function(expected, actual){
if(expected.length != actual.length){ return false; }
// FIXME: we're not handling circular refs. Do we care?
for(var x=0; x<expected.length; x++){
if(!doh.assertEqual(expected[x], actual[x])){ return false; }
}
return true;
}
doh._objPropEq = function(expected, actual){
// Degenerate case: if they are both null, then their "properties" are equal.
if(expected === null && actual === null){
return true;
}
// If only one is null, they aren't equal.
if(expected === null || actual === null){
return false;
}
if(expected instanceof Date){
return actual instanceof Date && expected.getTime()==actual.getTime();
}
var x;
// Make sure ALL THE SAME properties are in both objects!
for(x in actual){ // Lets check "actual" here, expected is checked below.
if(expected[x] === undefined){
return false;
}
};
for(x in expected){
if(!doh.assertEqual(expected[x], actual[x])){
return false;
}
}
return true;
}
doh._isArray = function(it){
return (it && it instanceof Array || typeof it == "array" ||
(
!!doh.global["dojo"] &&
doh.global["dojo"]["NodeList"] !== undefined &&
it instanceof doh.global["dojo"]["NodeList"]
)
);
}
//
// Runner-Wrapper
//
doh._setupGroupForRun = function(/*String*/ groupName, /*Integer*/ idx){
var tg = this._groups[groupName];
this.debug(this._line);
this.debug("GROUP", "\""+groupName+"\"", "has", tg.length, "test"+((tg.length > 1) ? "s" : "")+" to run");
}
doh._handleFailure = function(groupName, fixture, e){
// this.debug("FAILED test:", fixture.name);
// mostly borrowed from JUM
this._groups[groupName].failures++;
var out = "";
if(e instanceof this._AssertFailure){
this._failureCount++;
if(e["fileName"]){ out += e.fileName + ':'; }
if(e["lineNumber"]){ out += e.lineNumber + ' '; }
out += e+": "+e.message;
this.debug("\t_AssertFailure:", out);
}else{
this._errorCount++;
}
this.debug(e);
if(fixture.runTest["toSource"]){
var ss = fixture.runTest.toSource();
this.debug("\tERROR IN:\n\t\t", ss);
}else{
this.debug("\tERROR IN:\n\t\t", fixture.runTest);
}
if(e.rhinoException){
e.rhinoException.printStackTrace();
}else if(e.javaException){
e.javaException.printStackTrace();
}
}
//Assume a setTimeout implementation that is synchronous, so that
//the Node and Rhino envs work similar to each other. Node defines
//a setTimeout, so testing for setTimeout is not enough, each environment
//adapter should set this value accordingly.
doh.setTimeout = function(func){
return func();
};
doh._runPerfFixture = function(/*String*/groupName, /*Object*/fixture){
// summary:
// This function handles how to execute a 'performance' test
// which is different from a straight UT style test. These
// will often do numerous iterations of the same operation and
// gather execution statistics about it, like max, min, average,
// etc. It makes use of the already in place DOH deferred test
// handling since it is a good idea to put a pause inbetween each
// iteration to allow for GC cleanup and the like.
//
// groupName:
// The test group that contains this performance test.
// fixture:
// The performance test fixture.
var tg = this._groups[groupName];
fixture.startTime = new Date();
//Perf tests always need to act in an async manner as there is a
//number of iterations to flow through.
var def = new doh.Deferred();
tg.inFlight++;
def.groupName = groupName;
def.fixture = fixture;
def.addErrback(function(err){
doh._handleFailure(groupName, fixture, err);
});
//Set up the finalizer.
var retEnd = function(){
if(fixture["tearDown"]){ fixture.tearDown(doh); }
tg.inFlight--;
if((!tg.inFlight)&&(tg.iterated)){
doh._groupFinished(groupName, !tg.failures);
}
doh._testFinished(groupName, fixture, def.results[0]);
if(doh._paused){
doh.run();
}
};
//Since these can take who knows how long, we don't want to timeout
//unless explicitly set
var timer;
var to = fixture.timeout;
if(to > 0) {
timer = doh.setTimeout(function(){
// ret.cancel();
// retEnd();
def.errback(new Error("test timeout in "+fixture.name.toString()));
}, to);
}
//Set up the end calls to the test into the deferred we'll return.
def.addBoth(function(arg){
if(timer){
clearTimeout(timer);
}
retEnd();
});
//Okay, now set up the timing loop for the actual test.
//This is down as an async type test where there is a delay
//between each execution to allow for GC time, etc, so the GC
//has less impact on the tests.
var res = fixture.results;
res.trials = [];
//Try to figure out how many calls are needed to hit a particular threshold.
var itrDef = doh._calcTrialIterations(groupName, fixture);
itrDef.addErrback(function(err){
fixture.endTime = new Date();
def.errback(err);
});
//Blah, since tests can be deferred, the actual run has to be deferred until after
//we know how many iterations to run. This is just plain ugly.
itrDef.addCallback(function(iterations){
if(iterations){
var countdown = fixture.trialIterations;
doh.debug("TIMING TEST: [" + fixture.name +
"]\n\t\tITERATIONS PER TRIAL: " +
iterations + "\n\tTRIALS: " +
countdown);
//Figure out how many times we want to run our 'trial'.
//Where each trial consists of 'iterations' of the test.
var trialRunner = function() {
//Set up our function to execute a block of tests
var start = new Date();
var tTimer = new doh.Deferred();
var tCountdown = iterations;
var tState = {
countdown: iterations
};
var testRunner = function(state){
while(state){
try{
state.countdown--;
if(state.countdown){
var ret = fixture.runTest(doh);
if(ret instanceof doh.Deferred){
//Deferreds have to be handled async,
//otherwise we just keep looping.
var atState = {
countdown: state.countdown
};
ret.addCallback(function(){
testRunner(atState);
});
ret.addErrback(function(err) {
doh._handleFailure(groupName, fixture, err);
fixture.endTime = new Date();
def.errback(err);
});
state = null;
}
}else{
tTimer.callback(new Date());
state = null;
}
}catch(err){
fixture.endTime = new Date();
tTimer.errback(err);
}
}
};
tTimer.addCallback(function(end){
//Figure out the results and try to factor out function call costs.
var tResults = {
trial: (fixture.trialIterations - countdown),
testIterations: iterations,
executionTime: (end.getTime() - start.getTime()),
average: (end.getTime() - start.getTime())/iterations
};
res.trials.push(tResults);
doh.debug("\n\t\tTRIAL #: " +
tResults.trial + "\n\tTIME: " +
tResults.executionTime + "ms.\n\tAVG TEST TIME: " +
(tResults.executionTime/tResults.testIterations) + "ms.");
//Okay, have we run all the trials yet?
countdown--;
if(countdown){
doh.setTimeout(trialRunner, fixture.trialDelay);
}else{
//Okay, we're done, lets compute some final performance results.
var t = res.trials;
//We're done.
fixture.endTime = new Date();
def.callback(true);
}
});
tTimer.addErrback(function(err){
fixture.endTime = new Date();
def.errback(err);
});
testRunner(tState);
};
trialRunner();
}
});
//Set for a pause, returned the deferred.
if(def.fired < 0){
doh.pause();
}
return def;
};
doh._calcTrialIterations = function(/*String*/ groupName, /*Object*/ fixture){
// summary:
// This function determines the rough number of iterations to
// use to reach a particular MS threshold. This returns a deferred
// since tests can theoretically by async. Async tests aren't going to
// give great perf #s, though.
// The callback is passed the # of iterations to hit the requested
// threshold.
//
// fixture:
// The test fixture we want to calculate iterations for.
var def = new doh.Deferred();
var calibrate = function () {
var testFunc = fixture.runTest;
//Set the initial state. We have to do this as a loop instead
//of a recursive function. Otherwise, it blows the call stack
//on some browsers.
var iState = {
start: new Date(),
curIter: 0,
iterations: 5
};
var handleIteration = function(state){
while(state){
if(state.curIter < state.iterations){
try{
var ret = testFunc(doh);
if(ret instanceof doh.Deferred){
var aState = {
start: state.start,
curIter: state.curIter + 1,
iterations: state.iterations
};
ret.addCallback(function(){
handleIteration(aState);
});
ret.addErrback(function(err) {
fixture.endTime = new Date();
def.errback(err);
});
state = null;
}else{
state.curIter++;
}
}catch(err){
fixture.endTime = new Date();
def.errback(err);
return;
}
}else{
var end = new Date();
var totalTime = (end.getTime() - state.start.getTime());
if(totalTime < fixture.trialDuration){
var nState = {
iterations: state.iterations * 2,
curIter: 0
}
state = null;
doh.setTimeout(function(){
nState.start = new Date();
handleIteration(nState);
}, 50);
}else{
var itrs = state.iterations;
doh.setTimeout(function(){def.callback(itrs)}, 50);
state = null;
}
}
}
};
handleIteration(iState);
};
doh.setTimeout(calibrate, 10);
return def;
};
doh._runRegFixture = function(/*String*/groupName, /*Object*/fixture){
// summary:
// Function to run a generic doh test. These are not
// specialized tests, like performance groups and such.
//
// groupName:
// The groupName of the test.
// fixture:
// The test fixture to execute.
var tg = this._groups[groupName];
fixture.startTime = new Date();
var ret = fixture.runTest(this);
fixture.endTime = new Date();
// if we get a deferred back from the test runner, we know we're
// gonna wait for an async result. It's up to the test code to trap
// errors and give us an errback or callback.
if(ret instanceof doh.Deferred){
tg.inFlight++;
ret.groupName = groupName;
ret.fixture = fixture;
ret.addErrback(function(err){
doh._handleFailure(groupName, fixture, err);
});
var retEnd = function(){
if(fixture["tearDown"]){ fixture.tearDown(doh); }
tg.inFlight--;
if((!tg.inFlight)&&(tg.iterated)){
doh._groupFinished(groupName, !tg.failures);
}
doh._testFinished(groupName, fixture, ret.results[0]);
if(doh._paused){
doh.run();
}
}
var timer = doh.setTimeout(function(){
// ret.cancel();
// retEnd();
ret.errback(new Error("test timeout in "+fixture.name.toString()));
}, fixture["timeout"]||1000);
ret.addBoth(function(arg){
clearTimeout(timer);
retEnd();
});
if(ret.fired < 0){
doh.pause();
}
return ret;
}
};
doh._runFixture = function(groupName, fixture){
var tg = this._groups[groupName];
this._testStarted(groupName, fixture);
var threw = false;
var err = null;
// run it, catching exceptions and reporting them
try{
// let doh reference "this.group.thinger..." which can be set by
// another test or group-level setUp function
fixture.group = tg;
// only execute the parts of the fixture we've got
if(fixture["setUp"]){ fixture.setUp(this); }
if(fixture["runTest"]){ // should we error out of a fixture doesn't have a runTest?
if(fixture.testType === "perf"){
//Always async deferred, so return it.
return doh._runPerfFixture(groupName, fixture);
}else{
//May or may not by async.
var ret = doh._runRegFixture(groupName, fixture);
if(ret){
return ret;
}
}
}
if(fixture["tearDown"]){ fixture.tearDown(this); }
}catch(e){
threw = true;
err = e;
if(!fixture.endTime){
fixture.endTime = new Date();
}
}
var d = new doh.Deferred();
doh.setTimeout(this.hitch(this, function(){
if(threw){
this._handleFailure(groupName, fixture, err);
}
this._testFinished(groupName, fixture, !threw);
if((!tg.inFlight)&&(tg.iterated)){
doh._groupFinished(groupName, !tg.failures);
}else if(tg.inFlight > 0){
doh.setTimeout(this.hitch(this, function(){
doh.runGroup(groupName); // , idx);
}), 100);
this._paused = true;
}
if(doh._paused){
doh.run();
}
}), 30);
doh.pause();
return d;
}
doh._testId = 0;
doh.runGroup = function(/*String*/ groupName, /*Integer*/ idx){
// summary:
// runs the specified test group
// the general structure of the algorithm is to run through the group's
// list of doh, checking before and after each of them to see if we're in
// a paused state. This can be caused by the test returning a deferred or
// the user hitting the pause button. In either case, we want to halt
// execution of the test until something external to us restarts it. This
// means we need to pickle off enough state to pick up where we left off.
// FIXME: need to make fixture execution async!!
var tg = this._groups[groupName];
if(tg.skip === true){ return; }
if(this._isArray(tg)){
if(idx<=tg.length){
if((!tg.inFlight)&&(tg.iterated == true)){
if(tg["tearDown"]){ tg.tearDown(this); }
doh._groupFinished(groupName, !tg.failures);
return;
}
}
if(!idx){
tg.inFlight = 0;
tg.iterated = false;
tg.failures = 0;
}
doh._groupStarted(groupName);
if(!idx){
this._setupGroupForRun(groupName, idx);
if(tg["setUp"]){ tg.setUp(this); }
}
for(var y=(idx||0); y<tg.length; y++){
if(this._paused){
this._currentTest = y;
// this.debug("PAUSED at:", tg[y].name, this._currentGroup, this._currentTest);
return;
}
doh._runFixture(groupName, tg[y]);
if(this._paused){
this._currentTest = y+1;
if(this._currentTest == tg.length){
tg.iterated = true;
}
// this.debug("PAUSED at:", tg[y].name, this._currentGroup, this._currentTest);
return;
}
}
tg.iterated = true;
if(!tg.inFlight){
if(tg["tearDown"]){ tg.tearDown(this); }
doh._groupFinished(groupName, !tg.failures);
}
}
}
doh._onEnd = function(){}
doh._report = function(){
// summary:
// a private method to be implemented/replaced by the "locally
// appropriate" test runner
// this.debug("ERROR:");
// this.debug("\tNO REPORTING OUTPUT AVAILABLE.");
// this.debug("\tIMPLEMENT doh._report() IN YOUR TEST RUNNER");
this.debug(this._line);
this.debug("| TEST SUMMARY:");
this.debug(this._line);
this.debug("\t", this._testCount, "tests in", this._groupCount, "groups");
this.debug("\t", this._errorCount, "errors");
this.debug("\t", this._failureCount, "failures");
}
doh.togglePaused = function(){
this[(this._paused) ? "run" : "pause"]();
}
doh.pause = function(){
// summary:
// halt test run. Can be resumed.
this._paused = true;
}
doh.run = function(){
// summary:
// begins or resumes the test process.
// this.debug("STARTING");
this._paused = false;
var cg = this._currentGroup;
var ct = this._currentTest;
var found = false;
if(!cg){
this._init(); // we weren't paused
found = true;
}
this._currentGroup = null;
this._currentTest = null;
for(var x in this._groups){
if(
( (!found)&&(x == cg) )||( found )
){
if(this._paused){ return; }
this._currentGroup = x;
if(!found){
found = true;
this.runGroup(x, ct);
}else{
this.runGroup(x);
}
if(this._paused){ return; }
}
}
this._currentGroup = null;
this._currentTest = null;
this._paused = false;
this._onEnd();
this._report();
}
//Statistics functions to handle computing performance metrics.
//Taken from dojox.math
// basic statistics
doh.standardDeviation = function(/* Number[] */a){
// summary:
// Returns the standard deviation of the passed arguments.
return Math.sqrt(this.variance(a)); // Number
};
doh.variance = function(/* Number[] */a){
// summary:
// Find the variance in the passed array of numbers.
var mean=0, squares=0;
dojo.forEach(a, function(item){
mean+=item;
squares+=Math.pow(item,2);
});
return (squares/a.length)-Math.pow(mean/a.length, 2); // Number
};
doh.mean = function(/* Number[] */a){
// summary:
// Returns the mean value in the passed array.
var t=0;
dojo.forEach(a, function(v){
t += v;
});
return t / Math.max(a.length, 1); // Number
};
doh.min = function(/* Number[] */a){
// summary:
// Returns the min value in the passed array.
return Math.min.apply(null, a); // Number
};
doh.max = function(/* Number[] */a){
// summary:
// Returns the max value in the passed array.
return Math.max.apply(null, a); // Number
},
doh.median= function(/* Number[] */a){
// summary:
// Returns the value closest to the middle from a sorted version of the passed array.
return a.slice(0).sort()[Math.ceil(a.length/2)-1]; // Number
},
doh.mode = function(/* Number[] */a){
// summary:
// Returns the mode from the passed array (number that appears the most often).
// This is not the most efficient method, since it requires a double scan, but
// is ensures accuracy.
var o = {}, r = 0, m = Number.MIN_VALUE;
dojo.forEach(a, function(v){
(o[v]!==undefined)?o[v]++:o[v]=1;
});
// we did the lookup map because we need the number that appears the most.
for(var p in o){
if(m < o[p]){
m = o[p], r = p;
}
}
return r; // Number
};
doh.average = function(/* Number [] */ a){
var i;
var s = 0;
for(i = 0; i < a.length; i++){
s += a[i];
}
return s/a.length;
}
tests = doh;
if (typeof skipDohSetup === "undefined") {
(function(){
// scope protection
var x;
try{
if(typeof dojo != "undefined"){
dojo.platformRequire({
browser: ["doh._browserRunner"],
rhino: ["doh._rhinoRunner"],
spidermonkey: ["doh._rhinoRunner"]
});
try{
var _shouldRequire = dojo.isBrowser ? (dojo.global == dojo.global["parent"] || !Boolean(dojo.global.parent.doh) ) : true;
}catch(e){
//can't access dojo.global.parent.doh, then we need to do require
_shouldRequire = true;
}
if(_shouldRequire){
if(dojo.isBrowser){
dojo.addOnLoad(function(){
if (dojo.global.registerModulePath){
dojo.forEach(dojo.global.registerModulePath, function(m){
dojo.registerModulePath(m[0], m[1]);
});
}
if(dojo.byId("testList")){
var _tm = ( (dojo.global.testModule && dojo.global.testModule.length) ? dojo.global.testModule : "dojo.tests.module");
dojo.forEach(_tm.split(","), dojo.require, dojo);
doh.setTimeout(function(){
doh.run();
}, 500);
}
});
}else{
// dojo.require("doh._base");
}
}
}else{
if(typeof load == "function" &&
(typeof Packages == "function" || typeof Packages == "object")){
throw new Error();
}else if(typeof load == "function"){
throw new Error();
}
if(this["document"]){
/*
// if we survived all of that, we're probably in a browser but
// don't have Dojo handy. Load _browserRunner.js using a
// document.write() call.
// find runner.js, load _browserRunner relative to it
var scripts = document.getElementsByTagName("script"), runnerFile;
for(x=0; x<scripts.length; x++){
var s = scripts[x].src;
if(s){
if(!runnerFile && s.substr(s.length - 9) == "runner.js"){
runnerFile = s;
}else if(s.substr(s.length - 17) == "_browserRunner.js"){
runnerFile = null;
break;
}
}
}
if(runnerFile){
document.write("<scri"+"pt src='" + runnerFile.substr(0, runnerFile.length - 9)
+ "_browserRunner.js' type='text/javascript'></scr"+"ipt>");
}
*/
}
}
}catch(e){
print("\n"+doh._line);
print("The Dojo Unit Test Harness, $Rev: 20389 $");
print("Copyright (c) 2009, The Dojo Foundation, All Rights Reserved");
print(doh._line, "\n");
try{
var dojoUrl = "../../dojo/dojo.js";
var testUrl = "";
var testModule = "dojo.tests.module";
var dohBase = "";
for(x=0; x<arguments.length; x++){
if(arguments[x].indexOf("=") > 0){
var tp = arguments[x].split("=");
if(tp[0] == "dohBase"){
dohBase = tp[1];
//Convert slashes to unix style and make sure properly
//ended.
dohBase = dohBase.replace(/\\/g, "/");
if(dohBase.charAt(dohBase.length - 1) != "/"){
dohBase += "/";
}
}
if(tp[0] == "dojoUrl"){
dojoUrl = tp[1];
}
if(tp[0] == "testUrl"){
testUrl = tp[1];
}
if(tp[0] == "testModule"){
testModule = tp[1];
}
}
}
load(dohBase + "_rhinoRunner.js");
if(dojoUrl.length){
if(!this["djConfig"]){
djConfig = {};
}
djConfig.baseUrl = dojoUrl.split("dojo.js")[0];
load(dojoUrl);
}
if(testUrl.length){
load(testUrl);
}
if(testModule.length){
dojo.forEach(testModule.split(","), dojo.require, dojo);
}
}catch(e){
print("An exception occurred: " + e);
}
doh.run();
}
}).apply(this, typeof arguments != "undefined" ? arguments : [null]);
}
Reference in a new issue Copy permalink