--- /dev/null
+// FIXME: need to add async tests
+// FIXME: need to handle URL wrapping and test registration/running from URLs
+
+// package system gunk.
+try{
+ dojo.provide("doh.runner");
+}catch(e){
+ if(!this["doh"]){
+ doh = {};
+ }
+}
+
+//
+// Utility Functions and Classes
+//
+
+doh.selfTest = false;
+
+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((typeof 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){
+ // 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);
+ }
+ 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, {
+ getTestCallback: function(cb, scope){
+ var _this = this;
+ return function(){
+ try{
+ cb.apply(scope||dojo.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 dojo.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){
+ // 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
+ if(tests){
+ this.register(group, tests);
+ }
+ if(setUp){
+ this._groups[group].setUp = setUp;
+ }
+ if(tearDown){
+ this._groups[group].tearDown = tearDown;
+ }
+}
+
+doh._getTestObj = function(group, test){
+ 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", "_")
+ };
+ 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
+ }
+ return tObj;
+}
+
+doh.registerTest = function(/*String*/ group, /*Function||Object*/ test){
+ // 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.
+ if(!this._groups[group]){
+ this._groupCount++;
+ this._groups[group] = [];
+ this._groups[group].inFlight = 0;
+ }
+ var tObj = this._getTestObj(group, test);
+ if(!tObj){ return; }
+ this._groups[group].push(tObj);
+ this._testCount++;
+ this._testRegistered(group, tObj);
+ return tObj;
+}
+
+doh.registerTests = function(/*String*/ group, /*Array*/ testArr){
+ // summary:
+ // registers a group of tests, treating each element of testArr as
+ // though it were being (along with group) passed to the registerTest
+ // method.
+ for(var x=0; x<testArr.length; x++){
+ this.registerTest(group, testArr[x]);
+ }
+}
+
+// FIXME: move implementation to _browserRunner?
+doh.registerUrl = function( /*String*/ group,
+ /*String*/ url,
+ /*Integer*/ timeout){
+ this.debug("ERROR:");
+ this.debug("\tNO registerUrl() METHOD AVAILABLE.");
+ // this._urls.push(url);
+}
+
+doh.registerString = function(group, str){
+}
+
+// FIXME: remove the doh.add alias SRTL.
+doh.register = doh.add = function(groupOrNs, testOrNull){
+ // 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);
+ }else{
+ this.registerTest("ungrouped", groupOrNs);
+ }
+ }
+ 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);
+ }else{
+ this.registerTest(groupOrNs, testOrNull);
+ }
+ // this.registerTestNs(groupOrNs, testOrNull);
+ return;
+ }
+ if(doh._isArray(testOrNull)){
+ this.registerTests(groupOrNs, testOrNull);
+ return;
+ }
+ this.registerTest(groupOrNs, testOrNull);
+}
+
+//
+// Assertions and In-Test Utilities
+//
+
+doh.t = doh.assertTrue = function(/*Object*/ condition){
+ // summary:
+ // is the passed item "truthy"?
+ if(arguments.length != 1){
+ throw doh._AssertFailure("assertTrue failed because it was not passed exactly 1 argument");
+ }
+ if(!eval(condition)){
+ throw doh._AssertFailure("assertTrue('" + condition + "') failed");
+ }
+}
+
+doh.f = doh.assertFalse = function(/*Object*/ condition){
+ // summary:
+ // is the passed item "falsey"?
+ if(arguments.length != 1){
+ throw doh._AssertFailure("assertFalse failed because it was not passed exactly 1 argument");
+ }
+ if(eval(condition)){
+ throw doh._AssertFailure("assertFalse('" + condition + "') failed");
+ }
+}
+
+doh.e = doh.assertError = function(/*Error object*/expectedError, /*Object*/scope, /*String*/functionName, /*Array*/args){
+ // 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");
+ }
+ }
+ throw new doh._AssertFailure("assertError() failed:\n\texpected error\n\t\t"+expectedError+"\n\tbut no error caught\n\n");
+}
+
+
+doh.is = doh.assertEqual = function(/*Object*/ expected, /*Object*/ actual){
+ // 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)){
+ 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");
+}
+
+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){
+ if(expected instanceof Date){
+ return actual instanceof Date && expected.getTime()==actual.getTime();
+ }
+ // Make sure ALL THE SAME properties are in both objects!
+ for(var x in actual){ // Lets check "actual" here, expected is checked below.
+ if(expected[x] === undefined){
+ return false;
+ }
+ };
+
+ for(var 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" || (dojo["NodeList"] !== undefined && it instanceof 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();
+ }
+}
+
+try{
+ setTimeout(function(){}, 0);
+}catch(e){
+ setTimeout = function(func){
+ return func();
+ }
+}
+
+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?
+ 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 = 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;
+ }
+ }
+ if(fixture["tearDown"]){ fixture.tearDown(this); }
+ }catch(e){
+ threw = true;
+ err = e;
+ if(!fixture.endTime){
+ fixture.endTime = new Date();
+ }
+ }
+ var d = new doh.Deferred();
+ 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){
+ 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();
+}
+
+tests = doh;
+
+(function(){
+ // scop protection
+ try{
+ if(typeof dojo != "undefined"){
+ dojo.platformRequire({
+ browser: ["doh._browserRunner"],
+ rhino: ["doh._rhinoRunner"],
+ spidermonkey: ["doh._rhinoRunner"]
+ });
+ var _shouldRequire = (dojo.isBrowser) ? (dojo.global == dojo.global["parent"]) : true;
+ if(_shouldRequire){
+ if(dojo.isBrowser){
+ dojo.addOnLoad(function(){
+ 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);
+ 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();
+ }
+ }
+ }catch(e){
+ print("\n"+doh._line);
+ print("The Dojo Unit Test Harness, $Rev$");
+ print("Copyright (c) 2007, The Dojo Foundation, All Rights Reserved");
+ print(doh._line, "\n");
+
+ load("_rhinoRunner.js");
+
+ try{
+ var dojoUrl = "../../dojo/dojo.js";
+ var testUrl = "";
+ var testModule = "dojo.tests.module";
+ for(var x=0; x<arguments.length; x++){
+ if(arguments[x].indexOf("=") > 0){
+ var tp = arguments[x].split("=");
+ if(tp[0] == "dojoUrl"){
+ dojoUrl = tp[1];
+ }
+ if(tp[0] == "testUrl"){
+ testUrl = tp[1];
+ }
+ if(tp[0] == "testModule"){
+ testModule = tp[1];
+ }
+ }
+ }
+ 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]);
projects / eow / blobdiff