Subversion Repositories Applications.papyrus

// 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: expected error |"+expectedError+"| but got |"+e+"|");

		}

	}

	throw new doh._AssertFailure("assertError() failed: expected error |"+expectedError+"| but no error caught.");

}

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: expected |"+expected+"| but got |"+actual+"|");

}

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){

	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" || ((typeof 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);

	}

}

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){

		}

		doh.run();

	}

})();