|
|
@@ -0,0 +1,1499 @@
|
|
|
+// 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]);
|
|
|
+}
|
jrburke
