Diffusion SHRINE MedCo Fork (hotfix/1.21.2) Browse

1.21.2

yuitest.js
View Options

			/*
			Copyright (c) 2010, Yahoo! Inc. All rights reserved.
			Code licensed under the BSD License:
			http://developer.yahoo.com/yui/license.html
			version: 2.8.2r1
			*/
			YAHOO.namespace("tool");

			//-----------------------------------------------------------------------------
			// TestCase object
			//-----------------------------------------------------------------------------
			(function(){

			//used for autogenerating test case names
			var tempId = 0;

			/**
			* Test case containing various tests to run.
			* @param template An object containing any number of test methods, other methods,
			* an optional name, and anything else the test case needs.
			* @class TestCase
			* @namespace YAHOO.tool
			* @constructor
			*/
			YAHOO.tool.TestCase = function (template /:Object/) {

			/**
			* Special rules for the test case. Possible subobjects
			* are fail, for tests that should fail, and error, for
			* tests that should throw an error.
			*/
			this._should /:Object/ = {};

			//copy over all properties from the template to this object
			for (var prop in template) {
			this[prop] = template[prop];
			}

			//check for a valid name
			if (!YAHOO.lang.isString(this.name)){
			/**
			* Name for the test case.
			*/
			this.name /:String/ = "testCase" + (tempId++);
			}

			};


			YAHOO.tool.TestCase.prototype = {

			/**
			* Resumes a paused test and runs the given function.
			* @param {Function} segment (Optional) The function to run.
			* If omitted, the test automatically passes.
			* @return {Void}
			* @method resume
			*/
			resume : function (segment /:Function/) /:Void/ {
			YAHOO.tool.TestRunner.resume(segment);
			},

			/**
			* Causes the test case to wait a specified amount of time and then
			* continue executing the given code.
			* @param {Function} segment (Optional) The function to run after the delay.
			* If omitted, the TestRunner will wait until resume() is called.
			* @param {int} delay (Optional) The number of milliseconds to wait before running
			* the function. If omitted, defaults to zero.
			* @return {Void}
			* @method wait
			*/
			wait : function (segment /:Function/, delay /:int/) /:Void/{
			var args = arguments;
			if (YAHOO.lang.isFunction(args[0])){
			throw new YAHOO.tool.TestCase.Wait(args[0], args[1]);
			} else {
			throw new YAHOO.tool.TestCase.Wait(function(){
			YAHOO.util.Assert.fail("Timeout: wait() called but resume() never called.");
			}, (YAHOO.lang.isNumber(args[0]) ? args[0] : 10000));
			}
			},

			//-------------------------------------------------------------------------
			// Stub Methods
			//-------------------------------------------------------------------------

			/**
			* Function to run before each test is executed.
			* @return {Void}
			* @method setUp
			*/
			setUp : function () /:Void/ {
			},

			/**
			* Function to run after each test is executed.
			* @return {Void}
			* @method tearDown
			*/
			tearDown: function () /:Void/ {
			}
			};

			/**
			* Represents a stoppage in test execution to wait for an amount of time before
			* continuing.
			* @param {Function} segment A function to run when the wait is over.
			* @param {int} delay The number of milliseconds to wait before running the code.
			* @class Wait
			* @namespace YAHOO.tool.TestCase
			* @constructor
			*
			*/
			YAHOO.tool.TestCase.Wait = function (segment /:Function/, delay /:int/) {

			/**
			* The segment of code to run when the wait is over.
			* @type Function
			* @property segment
			*/
			this.segment /:Function/ = (YAHOO.lang.isFunction(segment) ? segment : null);

			/**
			* The delay before running the segment of code.
			* @type int
			* @property delay
			*/
			this.delay /:int/ = (YAHOO.lang.isNumber(delay) ? delay : 0);

			};

			})();
			YAHOO.namespace("tool");


			//-----------------------------------------------------------------------------
			// TestSuite object
			//-----------------------------------------------------------------------------

			/**
			* A test suite that can contain a collection of TestCase and TestSuite objects.
			* @param {String\|\|Object} data The name of the test suite or an object containing
			* a name property as well as setUp and tearDown methods.
			* @namespace YAHOO.tool
			* @class TestSuite
			* @constructor
			*/
			YAHOO.tool.TestSuite = function (data /:String\|\|Object/) {

			/**
			* The name of the test suite.
			* @type String
			* @property name
			*/
			this.name /:String/ = "";

			/**
			* Array of test suites and
			* @private
			*/
			this.items /:Array/ = [];

			//initialize the properties
			if (YAHOO.lang.isString(data)){
			this.name = data;
			} else if (YAHOO.lang.isObject(data)){
			YAHOO.lang.augmentObject(this, data, true);
			}

			//double-check name
			if (this.name === ""){
			this.name = YAHOO.util.Dom.generateId(null, "testSuite");
			}

			};

			YAHOO.tool.TestSuite.prototype = {

			/**
			* Adds a test suite or test case to the test suite.
			* @param {YAHOO.tool.TestSuite\|\|YAHOO.tool.TestCase} testObject The test suite or test case to add.
			* @return {Void}
			* @method add
			*/
			add : function (testObject /:YAHOO.tool.TestSuite/) /:Void/ {
			if (testObject instanceof YAHOO.tool.TestSuite \|\| testObject instanceof YAHOO.tool.TestCase) {
			this.items.push(testObject);
			}
			},

			//-------------------------------------------------------------------------
			// Stub Methods
			//-------------------------------------------------------------------------

			/**
			* Function to run before each test is executed.
			* @return {Void}
			* @method setUp
			*/
			setUp : function () /:Void/ {
			},

			/**
			* Function to run after each test is executed.
			* @return {Void}
			* @method tearDown
			*/
			tearDown: function () /:Void/ {
			}

			};
			YAHOO.namespace("tool");

			/**
			* The YUI test tool
			* @module yuitest
			* @namespace YAHOO.tool
			* @requires yahoo,dom,event,logger
			* @optional event-simulte
			*/


			//-----------------------------------------------------------------------------
			// TestRunner object
			//-----------------------------------------------------------------------------


			YAHOO.tool.TestRunner = (function(){

			/**
			* A node in the test tree structure. May represent a TestSuite, TestCase, or
			* test function.
			* @param {Variant} testObject A TestSuite, TestCase, or the name of a test function.
			* @class TestNode
			* @constructor
			* @private
			*/
			function TestNode(testObject /:Variant/){

			/**
			* The TestSuite, TestCase, or test function represented by this node.
			* @type Variant
			* @property testObject
			*/
			this.testObject = testObject;

			/**
			* Pointer to this node's first child.
			* @type TestNode
			* @property firstChild
			*/
			this.firstChild /:TestNode/ = null;

			/**
			* Pointer to this node's last child.
			* @type TestNode
			* @property lastChild
			*/
			this.lastChild = null;

			/**
			* Pointer to this node's parent.
			* @type TestNode
			* @property parent
			*/
			this.parent = null;

			/**
			* Pointer to this node's next sibling.
			* @type TestNode
			* @property next
			*/
			this.next = null;

			/**
			* Test results for this test object.
			* @type object
			* @property results
			*/
			this.results /:Object/ = {
			passed : 0,
			failed : 0,
			total : 0,
			ignored : 0
			};

			//initialize results
			if (testObject instanceof YAHOO.tool.TestSuite){
			this.results.type = "testsuite";
			this.results.name = testObject.name;
			} else if (testObject instanceof YAHOO.tool.TestCase){
			this.results.type = "testcase";
			this.results.name = testObject.name;
			}

			}

			TestNode.prototype = {

			/**
			* Appends a new test object (TestSuite, TestCase, or test function name) as a child
			* of this node.
			* @param {Variant} testObject A TestSuite, TestCase, or the name of a test function.
			* @return {Void}
			*/
			appendChild : function (testObject /:Variant/) /:Void/{
			var node = new TestNode(testObject);
			if (this.firstChild === null){
			this.firstChild = this.lastChild = node;
			} else {
			this.lastChild.next = node;
			this.lastChild = node;
			}
			node.parent = this;
			return node;
			}
			};

			/**
			* Runs test suites and test cases, providing events to allowing for the
			* interpretation of test results.
			* @namespace YAHOO.tool
			* @class TestRunner
			* @static
			*/
			function TestRunner(){

			//inherit from EventProvider
			TestRunner.superclass.constructor.apply(this,arguments);

			/**
			* Suite on which to attach all TestSuites and TestCases to be run.
			* @type YAHOO.tool.TestSuite
			* @property masterSuite
			* @private
			* @static
			*/
			this.masterSuite /:YAHOO.tool.TestSuite/ = new YAHOO.tool.TestSuite("YUI Test Results");

			/**
			* Pointer to the current node in the test tree.
			* @type TestNode
			* @private
			* @property _cur
			* @static
			*/
			this._cur = null;

			/**
			* Pointer to the root node in the test tree.
			* @type TestNode
			* @private
			* @property _root
			* @static
			*/
			this._root = null;

			//create events
			var events /:Array/ = [
			this.TEST_CASE_BEGIN_EVENT,
			this.TEST_CASE_COMPLETE_EVENT,
			this.TEST_SUITE_BEGIN_EVENT,
			this.TEST_SUITE_COMPLETE_EVENT,
			this.TEST_PASS_EVENT,
			this.TEST_FAIL_EVENT,
			this.TEST_IGNORE_EVENT,
			this.COMPLETE_EVENT,
			this.BEGIN_EVENT
			];
			for (var i=0; i < events.length; i++){
			this.createEvent(events[i], { scope: this });
			}

			}

			YAHOO.lang.extend(TestRunner, YAHOO.util.EventProvider, {

			//-------------------------------------------------------------------------
			// Constants
			//-------------------------------------------------------------------------

			/**
			* Fires when a test case is opened but before the first
			* test is executed.
			* @event testcasebegin
			*/
			TEST_CASE_BEGIN_EVENT /:String/ : "testcasebegin",

			/**
			* Fires when all tests in a test case have been executed.
			* @event testcasecomplete
			*/
			TEST_CASE_COMPLETE_EVENT /:String/ : "testcasecomplete",

			/**
			* Fires when a test suite is opened but before the first
			* test is executed.
			* @event testsuitebegin
			*/
			TEST_SUITE_BEGIN_EVENT /:String/ : "testsuitebegin",

			/**
			* Fires when all test cases in a test suite have been
			* completed.
			* @event testsuitecomplete
			*/
			TEST_SUITE_COMPLETE_EVENT /:String/ : "testsuitecomplete",

			/**
			* Fires when a test has passed.
			* @event pass
			*/
			TEST_PASS_EVENT /:String/ : "pass",

			/**
			* Fires when a test has failed.
			* @event fail
			*/
			TEST_FAIL_EVENT /:String/ : "fail",

			/**
			* Fires when a test has been ignored.
			* @event ignore
			*/
			TEST_IGNORE_EVENT /:String/ : "ignore",

			/**
			* Fires when all test suites and test cases have been completed.
			* @event complete
			*/
			COMPLETE_EVENT /:String/ : "complete",

			/**
			* Fires when the run() method is called.
			* @event begin
			*/
			BEGIN_EVENT /:String/ : "begin",

			//-------------------------------------------------------------------------
			// Test Tree-Related Methods
			//-------------------------------------------------------------------------

			/**
			* Adds a test case to the test tree as a child of the specified node.
			* @param {TestNode} parentNode The node to add the test case to as a child.
			* @param {YAHOO.tool.TestCase} testCase The test case to add.
			* @return {Void}
			* @static
			* @private
			* @method _addTestCaseToTestTree
			*/
			_addTestCaseToTestTree : function (parentNode /:TestNode/, testCase /:YAHOO.tool.TestCase/) /:Void/{

			//add the test suite
			var node = parentNode.appendChild(testCase);

			//iterate over the items in the test case
			for (var prop in testCase){
			if (prop.indexOf("test") === 0 && YAHOO.lang.isFunction(testCase[prop])){
			node.appendChild(prop);
			}
			}

			},

			/**
			* Adds a test suite to the test tree as a child of the specified node.
			* @param {TestNode} parentNode The node to add the test suite to as a child.
			* @param {YAHOO.tool.TestSuite} testSuite The test suite to add.
			* @return {Void}
			* @static
			* @private
			* @method _addTestSuiteToTestTree
			*/
			_addTestSuiteToTestTree : function (parentNode /:TestNode/, testSuite /:YAHOO.tool.TestSuite/) /:Void/ {

			//add the test suite
			var node = parentNode.appendChild(testSuite);

			//iterate over the items in the master suite
			for (var i=0; i < testSuite.items.length; i++){
			if (testSuite.items[i] instanceof YAHOO.tool.TestSuite) {
			this._addTestSuiteToTestTree(node, testSuite.items[i]);
			} else if (testSuite.items[i] instanceof YAHOO.tool.TestCase) {
			this._addTestCaseToTestTree(node, testSuite.items[i]);
			}
			}
			},

			/**
			* Builds the test tree based on items in the master suite. The tree is a hierarchical
			* representation of the test suites, test cases, and test functions. The resulting tree
			* is stored in _root and the pointer _cur is set to the root initially.
			* @return {Void}
			* @static
			* @private
			* @method _buildTestTree
			*/
			_buildTestTree : function () /:Void/ {

			this._root = new TestNode(this.masterSuite);
			this._cur = this._root;

			//iterate over the items in the master suite
			for (var i=0; i < this.masterSuite.items.length; i++){
			if (this.masterSuite.items[i] instanceof YAHOO.tool.TestSuite) {
			this._addTestSuiteToTestTree(this._root, this.masterSuite.items[i]);
			} else if (this.masterSuite.items[i] instanceof YAHOO.tool.TestCase) {
			this._addTestCaseToTestTree(this._root, this.masterSuite.items[i]);
			}
			}

			},

			//-------------------------------------------------------------------------
			// Private Methods
			//-------------------------------------------------------------------------

			/**
			* Handles the completion of a test object's tests. Tallies test results
			* from one level up to the next.
			* @param {TestNode} node The TestNode representing the test object.
			* @return {Void}
			* @method _handleTestObjectComplete
			* @private
			* @static
			*/
			_handleTestObjectComplete : function (node /:TestNode/) /:Void/ {
			if (YAHOO.lang.isObject(node.testObject)){
			node.parent.results.passed += node.results.passed;
			node.parent.results.failed += node.results.failed;
			node.parent.results.total += node.results.total;
			node.parent.results.ignored += node.results.ignored;
			node.parent.results[node.testObject.name] = node.results;

			if (node.testObject instanceof YAHOO.tool.TestSuite){
			node.testObject.tearDown();
			this.fireEvent(this.TEST_SUITE_COMPLETE_EVENT, { testSuite: node.testObject, results: node.results});
			} else if (node.testObject instanceof YAHOO.tool.TestCase){
			this.fireEvent(this.TEST_CASE_COMPLETE_EVENT, { testCase: node.testObject, results: node.results});
			}
			}
			},

			//-------------------------------------------------------------------------
			// Navigation Methods
			//-------------------------------------------------------------------------

			/**
			* Retrieves the next node in the test tree.
			* @return {TestNode} The next node in the test tree or null if the end is reached.
			* @private
			* @static
			* @method _next
			*/
			_next : function () /:TestNode/ {

			if (this._cur.firstChild) {
			this._cur = this._cur.firstChild;
			} else if (this._cur.next) {
			this._cur = this._cur.next;
			} else {
			while (this._cur && !this._cur.next && this._cur !== this._root){
			this._handleTestObjectComplete(this._cur);
			this._cur = this._cur.parent;
			}

			if (this._cur == this._root){
			this._cur.results.type = "report";
			this._cur.results.timestamp = (new Date()).toLocaleString();
			this._cur.results.duration = (new Date()) - this._cur.results.duration;
			this.fireEvent(this.COMPLETE_EVENT, { results: this._cur.results});
			this._cur = null;
			} else {
			this._handleTestObjectComplete(this._cur);
			this._cur = this._cur.next;
			}
			}

			return this._cur;
			},

			/**
			* Runs a test case or test suite, returning the results.
			* @param {YAHOO.tool.TestCase\|YAHOO.tool.TestSuite} testObject The test case or test suite to run.
			* @return {Object} Results of the execution with properties passed, failed, and total.
			* @private
			* @method _run
			* @static
			*/
			_run : function () /:Void/ {

			//flag to indicate if the TestRunner should wait before continuing
			var shouldWait /:Boolean/ = false;

			//get the next test node
			var node = this._next();

			if (node !== null) {
			var testObject = node.testObject;

			//figure out what to do
			if (YAHOO.lang.isObject(testObject)){
			if (testObject instanceof YAHOO.tool.TestSuite){
			this.fireEvent(this.TEST_SUITE_BEGIN_EVENT, { testSuite: testObject });
			testObject.setUp();
			} else if (testObject instanceof YAHOO.tool.TestCase){
			this.fireEvent(this.TEST_CASE_BEGIN_EVENT, { testCase: testObject });
			}

			//some environments don't support setTimeout
			if (typeof setTimeout != "undefined"){
			setTimeout(function(){
			YAHOO.tool.TestRunner._run();
			}, 0);
			} else {
			this._run();
			}
			} else {
			this._runTest(node);
			}

			}
			},

			_resumeTest : function (segment /:Function/) /:Void/ {

			//get relevant information
			var node /:TestNode/ = this._cur;
			var testName /:String/ = node.testObject;
			var testCase /:YAHOO.tool.TestCase/ = node.parent.testObject;

			//cancel other waits if available
			if (testCase.__yui_wait){
			clearTimeout(testCase.__yui_wait);
			delete testCase.__yui_wait;
			}

			//get the "should" test cases
			var shouldFail /:Object/ = (testCase._should.fail \|\| {})[testName];
			var shouldError /:Object/ = (testCase._should.error \|\| {})[testName];

			//variable to hold whether or not the test failed
			var failed /:Boolean/ = false;
			var error /:Error/ = null;

			//try the test
			try {

			//run the test
			segment.apply(testCase);

			//if it should fail, and it got here, then it's a fail because it didn't
			if (shouldFail){
			error = new YAHOO.util.ShouldFail();
			failed = true;
			} else if (shouldError){
			error = new YAHOO.util.ShouldError();
			failed = true;
			}

			} catch (thrown /:Error/){
			if (thrown instanceof YAHOO.util.AssertionError) {
			if (!shouldFail){
			error = thrown;
			failed = true;
			}
			} else if (thrown instanceof YAHOO.tool.TestCase.Wait){

			if (YAHOO.lang.isFunction(thrown.segment)){
			if (YAHOO.lang.isNumber(thrown.delay)){

			//some environments don't support setTimeout
			if (typeof setTimeout != "undefined"){
			testCase.__yui_wait = setTimeout(function(){
			YAHOO.tool.TestRunner._resumeTest(thrown.segment);
			}, thrown.delay);
			} else {
			throw new Error("Asynchronous tests not supported in this environment.");
			}
			}
			}

			return;

			} else {
			//first check to see if it should error
			if (!shouldError) {
			error = new YAHOO.util.UnexpectedError(thrown);
			failed = true;
			} else {
			//check to see what type of data we have
			if (YAHOO.lang.isString(shouldError)){

			//if it's a string, check the error message
			if (thrown.message != shouldError){
			error = new YAHOO.util.UnexpectedError(thrown);
			failed = true;
			}
			} else if (YAHOO.lang.isFunction(shouldError)){

			//if it's a function, see if the error is an instance of it
			if (!(thrown instanceof shouldError)){
			error = new YAHOO.util.UnexpectedError(thrown);
			failed = true;
			}

			} else if (YAHOO.lang.isObject(shouldError)){

			//if it's an object, check the instance and message
			if (!(thrown instanceof shouldError.constructor) \|\|
			thrown.message != shouldError.message){
			error = new YAHOO.util.UnexpectedError(thrown);
			failed = true;
			}

			}

			}
			}

			}

			//fireEvent appropriate event
			if (failed) {
			this.fireEvent(this.TEST_FAIL_EVENT, { testCase: testCase, testName: testName, error: error });
			} else {
			this.fireEvent(this.TEST_PASS_EVENT, { testCase: testCase, testName: testName });
			}

			//run the tear down
			testCase.tearDown();

			//update results
			node.parent.results[testName] = {
			result: failed ? "fail" : "pass",
			message: error ? error.getMessage() : "Test passed",
			type: "test",
			name: testName
			};

			if (failed){
			node.parent.results.failed++;
			} else {
			node.parent.results.passed++;
			}
			node.parent.results.total++;

			//set timeout not supported in all environments
			if (typeof setTimeout != "undefined"){
			setTimeout(function(){
			YAHOO.tool.TestRunner._run();
			}, 0);
			} else {
			this._run();
			}

			},

			/**
			* Runs a single test based on the data provided in the node.
			* @param {TestNode} node The TestNode representing the test to run.
			* @return {Void}
			* @static
			* @private
			* @name _runTest
			*/
			_runTest : function (node /:TestNode/) /:Void/ {

			//get relevant information
			var testName /:String/ = node.testObject;
			var testCase /:YAHOO.tool.TestCase/ = node.parent.testObject;
			var test /:Function/ = testCase[testName];

			//get the "should" test cases
			var shouldIgnore /:Object/ = (testCase._should.ignore \|\| {})[testName];

			//figure out if the test should be ignored or not
			if (shouldIgnore){

			//update results
			node.parent.results[testName] = {
			result: "ignore",
			message: "Test ignored",
			type: "test",
			name: testName
			};

			node.parent.results.ignored++;
			node.parent.results.total++;

			this.fireEvent(this.TEST_IGNORE_EVENT, { testCase: testCase, testName: testName });

			//some environments don't support setTimeout
			if (typeof setTimeout != "undefined"){
			setTimeout(function(){
			YAHOO.tool.TestRunner._run();
			}, 0);
			} else {
			this._run();
			}

			} else {

			//run the setup
			testCase.setUp();

			//now call the body of the test
			this._resumeTest(test);
			}

			},

			//-------------------------------------------------------------------------
			// Protected Methods
			//-------------------------------------------------------------------------

			/**
			* Fires events for the TestRunner. This overrides the default fireEvent()
			* method from EventProvider to add the type property to the data that is
			* passed through on each event call.
			* @param {String} type The type of event to fire.
			* @param {Object} data (Optional) Data for the event.
			* @method fireEvent
			* @static
			* @protected
			*/
			fireEvent : function (type /:String/, data /:Object/) /:Void/ {
			data = data \|\| {};
			data.type = type;
			TestRunner.superclass.fireEvent.call(this, type, data);
			},

			//-------------------------------------------------------------------------
			// Public Methods
			//-------------------------------------------------------------------------

			/**
			* Adds a test suite or test case to the list of test objects to run.
			* @param testObject Either a TestCase or a TestSuite that should be run.
			* @return {Void}
			* @method add
			* @static
			*/
			add : function (testObject /:Object/) /:Void/ {
			this.masterSuite.add(testObject);
			},

			/**
			* Removes all test objects from the runner.
			* @return {Void}
			* @method clear
			* @static
			*/
			clear : function () /:Void/ {
			this.masterSuite.items = [];
			},

			/**
			* Resumes the TestRunner after wait() was called.
			* @param {Function} segment The function to run as the rest
			* of the haulted test.
			* @return {Void}
			* @method resume
			* @static
			*/
			resume : function (segment /:Function/) /:Void/ {
			this._resumeTest(segment \|\| function(){});
			},

			/**
			* Runs the test suite.
			* @return {Void}
			* @method run
			* @static
			*/
			run : function (testObject /:Object/) /:Void/ {

			//pointer to runner to avoid scope issues
			var runner = YAHOO.tool.TestRunner;

			//build the test tree
			runner._buildTestTree();

			//set when the test started
			runner._root.results.duration = (new Date()).getTime();

			//fire the begin event
			runner.fireEvent(runner.BEGIN_EVENT);

			//begin the testing
			runner._run();
			}
			});

			return new TestRunner();

			})();
			YAHOO.namespace("util");

			//-----------------------------------------------------------------------------
			// Assert object
			//-----------------------------------------------------------------------------

			/**
			* The Assert object provides functions to test JavaScript values against
			* known and expected results. Whenever a comparison (assertion) fails,
			* an error is thrown.
			*
			* @namespace YAHOO.util
			* @class Assert
			* @static
			*/
			YAHOO.util.Assert = {

			//-------------------------------------------------------------------------
			// Helper Methods
			//-------------------------------------------------------------------------

			/**
			* Formats a message so that it can contain the original assertion message
			* in addition to the custom message.
			* @param {String} customMessage The message passed in by the developer.
			* @param {String} defaultMessage The message created by the error by default.
			* @return {String} The final error message, containing either or both.
			* @protected
			* @static
			* @method _formatMessage
			*/
			_formatMessage : function (customMessage /:String/, defaultMessage /:String/) /:String/ {
			var message = customMessage;
			if (YAHOO.lang.isString(customMessage) && customMessage.length > 0){
			return YAHOO.lang.substitute(customMessage, { message: defaultMessage });
			} else {
			return defaultMessage;
			}
			},

			//-------------------------------------------------------------------------
			// Generic Assertion Methods
			//-------------------------------------------------------------------------

			/**
			* Forces an assertion error to occur.
			* @param {String} message (Optional) The message to display with the failure.
			* @method fail
			* @static
			*/
			fail : function (message /:String/) /:Void/ {
			throw new YAHOO.util.AssertionError(this._formatMessage(message, "Test force-failed."));
			},

			//-------------------------------------------------------------------------
			// Equality Assertion Methods
			//-------------------------------------------------------------------------

			/**
			* Asserts that a value is equal to another. This uses the double equals sign
			* so type cohersion may occur.
			* @param {Object} expected The expected value.
			* @param {Object} actual The actual value to test.
			* @param {String} message (Optional) The message to display if the assertion fails.
			* @method areEqual
			* @static
			*/
			areEqual : function (expected /:Object/, actual /:Object/, message /:String/) /:Void/ {
			if (expected != actual) {
			throw new YAHOO.util.ComparisonFailure(this._formatMessage(message, "Values should be equal."), expected, actual);
			}
			},

			/**
			* Asserts that a value is not equal to another. This uses the double equals sign
			* so type cohersion may occur.
			* @param {Object} unexpected The unexpected value.
			* @param {Object} actual The actual value to test.
			* @param {String} message (Optional) The message to display if the assertion fails.
			* @method areNotEqual
			* @static
			*/
			areNotEqual : function (unexpected /:Object/, actual /:Object/,
			message /:String/) /:Void/ {
			if (unexpected == actual) {
			throw new YAHOO.util.UnexpectedValue(this._formatMessage(message, "Values should not be equal."), unexpected);
			}
			},

			/**
			* Asserts that a value is not the same as another. This uses the triple equals sign
			* so no type cohersion may occur.
			* @param {Object} unexpected The unexpected value.
			* @param {Object} actual The actual value to test.
			* @param {String} message (Optional) The message to display if the assertion fails.
			* @method areNotSame
			* @static
			*/
			areNotSame : function (unexpected /:Object/, actual /:Object/, message /:String/) /:Void/ {
			if (unexpected === actual) {
			throw new YAHOO.util.UnexpectedValue(this._formatMessage(message, "Values should not be the same."), unexpected);
			}
			},

			/**
			* Asserts that a value is the same as another. This uses the triple equals sign
			* so no type cohersion may occur.
			* @param {Object} expected The expected value.
			* @param {Object} actual The actual value to test.
			* @param {String} message (Optional) The message to display if the assertion fails.
			* @method areSame
			* @static
			*/
			areSame : function (expected /:Object/, actual /:Object/, message /:String/) /:Void/ {
			if (expected !== actual) {
			throw new YAHOO.util.ComparisonFailure(this._formatMessage(message, "Values should be the same."), expected, actual);
			}
			},

			//-------------------------------------------------------------------------
			// Boolean Assertion Methods
			//-------------------------------------------------------------------------

			/**
			* Asserts that a value is false. This uses the triple equals sign
			* so no type cohersion may occur.
			* @param {Object} actual The actual value to test.
			* @param {String} message (Optional) The message to display if the assertion fails.
			* @method isFalse
			* @static
			*/
			isFalse : function (actual /:Boolean/, message /:String/) {
			if (false !== actual) {
			throw new YAHOO.util.ComparisonFailure(this._formatMessage(message, "Value should be false."), false, actual);
			}
			},

			/**
			* Asserts that a value is true. This uses the triple equals sign
			* so no type cohersion may occur.
			* @param {Object} actual The actual value to test.
			* @param {String} message (Optional) The message to display if the assertion fails.
			* @method isTrue
			* @static
			*/
			isTrue : function (actual /:Boolean/, message /:String/) /:Void/ {
			if (true !== actual) {
			throw new YAHOO.util.ComparisonFailure(this._formatMessage(message, "Value should be true."), true, actual);
			}

			},

			//-------------------------------------------------------------------------
			// Special Value Assertion Methods
			//-------------------------------------------------------------------------

			/**
			* Asserts that a value is not a number.
			* @param {Object} actual The value to test.
			* @param {String} message (Optional) The message to display if the assertion fails.
			* @method isNaN
			* @static
			*/
			isNaN : function (actual /:Object/, message /:String/) /:Void/{
			if (!isNaN(actual)){
			throw new YAHOO.util.ComparisonFailure(this._formatMessage(message, "Value should be NaN."), NaN, actual);
			}
			},

			/**
			* Asserts that a value is not the special NaN value.
			* @param {Object} actual The value to test.
			* @param {String} message (Optional) The message to display if the assertion fails.
			* @method isNotNaN
			* @static
			*/
			isNotNaN : function (actual /:Object/, message /:String/) /:Void/{
			if (isNaN(actual)){
			throw new YAHOO.util.UnexpectedValue(this._formatMessage(message, "Values should not be NaN."), NaN);
			}
			},

			/**
			* Asserts that a value is not null. This uses the triple equals sign
			* so no type cohersion may occur.
			* @param {Object} actual The actual value to test.
			* @param {String} message (Optional) The message to display if the assertion fails.
			* @method isNotNull
			* @static
			*/
			isNotNull : function (actual /:Object/, message /:String/) /:Void/ {
			if (YAHOO.lang.isNull(actual)) {
			throw new YAHOO.util.UnexpectedValue(this._formatMessage(message, "Values should not be null."), null);
			}
			},

			/**
			* Asserts that a value is not undefined. This uses the triple equals sign
			* so no type cohersion may occur.
			* @param {Object} actual The actual value to test.
			* @param {String} message (Optional) The message to display if the assertion fails.
			* @method isNotUndefined
			* @static
			*/
			isNotUndefined : function (actual /:Object/, message /:String/) /:Void/ {
			if (YAHOO.lang.isUndefined(actual)) {
			throw new YAHOO.util.UnexpectedValue(this._formatMessage(message, "Value should not be undefined."), undefined);
			}
			},

			/**
			* Asserts that a value is null. This uses the triple equals sign
			* so no type cohersion may occur.
			* @param {Object} actual The actual value to test.
			* @param {String} message (Optional) The message to display if the assertion fails.
			* @method isNull
			* @static
			*/
			isNull : function (actual /:Object/, message /:String/) /:Void/ {
			if (!YAHOO.lang.isNull(actual)) {
			throw new YAHOO.util.ComparisonFailure(this._formatMessage(message, "Value should be null."), null, actual);
			}
			},

			/**
			* Asserts that a value is undefined. This uses the triple equals sign
			* so no type cohersion may occur.
			* @param {Object} actual The actual value to test.
			* @param {String} message (Optional) The message to display if the assertion fails.
			* @method isUndefined
			* @static
			*/
			isUndefined : function (actual /:Object/, message /:String/) /:Void/ {
			if (!YAHOO.lang.isUndefined(actual)) {
			throw new YAHOO.util.ComparisonFailure(this._formatMessage(message, "Value should be undefined."), undefined, actual);
			}
			},

			//--------------------------------------------------------------------------
			// Instance Assertion Methods
			//--------------------------------------------------------------------------

			/**
			* Asserts that a value is an array.
			* @param {Object} actual The value to test.
			* @param {String} message (Optional) The message to display if the assertion fails.
			* @method isArray
			* @static
			*/
			isArray : function (actual /:Object/, message /:String/) /:Void/ {
			if (!YAHOO.lang.isArray(actual)){
			throw new YAHOO.util.UnexpectedValue(this._formatMessage(message, "Value should be an array."), actual);
			}
			},

			/**
			* Asserts that a value is a Boolean.
			* @param {Object} actual The value to test.
			* @param {String} message (Optional) The message to display if the assertion fails.
			* @method isBoolean
			* @static
			*/
			isBoolean : function (actual /:Object/, message /:String/) /:Void/ {
			if (!YAHOO.lang.isBoolean(actual)){
			throw new YAHOO.util.UnexpectedValue(this._formatMessage(message, "Value should be a Boolean."), actual);
			}
			},

			/**
			* Asserts that a value is a function.
			* @param {Object} actual The value to test.
			* @param {String} message (Optional) The message to display if the assertion fails.
			* @method isFunction
			* @static
			*/
			isFunction : function (actual /:Object/, message /:String/) /:Void/ {
			if (!YAHOO.lang.isFunction(actual)){
			throw new YAHOO.util.UnexpectedValue(this._formatMessage(message, "Value should be a function."), actual);
			}
			},

			/**
			* Asserts that a value is an instance of a particular object. This may return
			* incorrect results when comparing objects from one frame to constructors in
			* another frame. For best results, don't use in a cross-frame manner.
			* @param {Function} expected The function that the object should be an instance of.
			* @param {Object} actual The object to test.
			* @param {String} message (Optional) The message to display if the assertion fails.
			* @method isInstanceOf
			* @static
			*/
			isInstanceOf : function (expected /:Function/, actual /:Object/, message /:String/) /:Void/ {
			if (!(actual instanceof expected)){
			throw new YAHOO.util.ComparisonFailure(this._formatMessage(message, "Value isn't an instance of expected type."), expected, actual);
			}
			},

			/**
			* Asserts that a value is a number.
			* @param {Object} actual The value to test.
			* @param {String} message (Optional) The message to display if the assertion fails.
			* @method isNumber
			* @static
			*/
			isNumber : function (actual /:Object/, message /:String/) /:Void/ {
			if (!YAHOO.lang.isNumber(actual)){
			throw new YAHOO.util.UnexpectedValue(this._formatMessage(message, "Value should be a number."), actual);
			}
			},

			/**
			* Asserts that a value is an object.
			* @param {Object} actual The value to test.
			* @param {String} message (Optional) The message to display if the assertion fails.
			* @method isObject
			* @static
			*/
			isObject : function (actual /:Object/, message /:String/) /:Void/ {
			if (!YAHOO.lang.isObject(actual)){
			throw new YAHOO.util.UnexpectedValue(this._formatMessage(message, "Value should be an object."), actual);
			}
			},

			/**
			* Asserts that a value is a string.
			* @param {Object} actual The value to test.
			* @param {String} message (Optional) The message to display if the assertion fails.
			* @method isString
			* @static
			*/
			isString : function (actual /:Object/, message /:String/) /:Void/ {
			if (!YAHOO.lang.isString(actual)){
			throw new YAHOO.util.UnexpectedValue(this._formatMessage(message, "Value should be a string."), actual);
			}
			},

			/**
			* Asserts that a value is of a particular type.
			* @param {String} expectedType The expected type of the variable.
			* @param {Object} actualValue The actual value to test.
			* @param {String} message (Optional) The message to display if the assertion fails.
			* @method isTypeOf
			* @static
			*/
			isTypeOf : function (expected /:String/, actual /:Object/, message /:String/) /:Void/{
			if (typeof actual != expected){
			throw new YAHOO.util.ComparisonFailure(this._formatMessage(message, "Value should be of type " + expected + "."), expected, typeof actual);
			}
			}
			};

			//-----------------------------------------------------------------------------
			// Assertion errors
			//-----------------------------------------------------------------------------

			/**
			* AssertionError is thrown whenever an assertion fails. It provides methods
			* to more easily get at error information and also provides a base class
			* from which more specific assertion errors can be derived.
			*
			* @param {String} message The message to display when the error occurs.
			* @namespace YAHOO.util
			* @class AssertionError
			* @extends Error
			* @constructor
			*/
			YAHOO.util.AssertionError = function (message /:String/){

			//call superclass
			//arguments.callee.superclass.constructor.call(this, message);

			/*
			* Error message. Must be duplicated to ensure browser receives it.
			* @type String
			* @property message
			*/
			this.message /:String/ = message;

			/**
			* The name of the error that occurred.
			* @type String
			* @property name
			*/
			this.name /:String/ = "AssertionError";
			};

			//inherit methods
			YAHOO.lang.extend(YAHOO.util.AssertionError, Object, {

			/**
			* Returns a fully formatted error for an assertion failure. This should
			* be overridden by all subclasses to provide specific information.
			* @method getMessage
			* @return {String} A string describing the error.
			*/
			getMessage : function () /:String/ {
			return this.message;
			},

			/**
			* Returns a string representation of the error.
			* @method toString
			* @return {String} A string representation of the error.
			*/
			toString : function () /:String/ {
			return this.name + ": " + this.getMessage();
			}

			});

			/**
			* ComparisonFailure is subclass of AssertionError that is thrown whenever
			* a comparison between two values fails. It provides mechanisms to retrieve
			* both the expected and actual value.
			*
			* @param {String} message The message to display when the error occurs.
			* @param {Object} expected The expected value.
			* @param {Object} actual The actual value that caused the assertion to fail.
			* @namespace YAHOO.util
			* @extends YAHOO.util.AssertionError
			* @class ComparisonFailure
			* @constructor
			*/
			YAHOO.util.ComparisonFailure = function (message /:String/, expected /:Object/, actual /:Object/){

			//call superclass
			YAHOO.util.AssertionError.call(this, message);

			/**
			* The expected value.
			* @type Object
			* @property expected
			*/
			this.expected /:Object/ = expected;

			/**
			* The actual value.
			* @type Object
			* @property actual
			*/
			this.actual /:Object/ = actual;

			/**
			* The name of the error that occurred.
			* @type String
			* @property name
			*/
			this.name /:String/ = "ComparisonFailure";

			};

			//inherit methods
			YAHOO.lang.extend(YAHOO.util.ComparisonFailure, YAHOO.util.AssertionError, {

			/**
			* Returns a fully formatted error for an assertion failure. This message
			* provides information about the expected and actual values.
			* @method toString
			* @return {String} A string describing the error.
			*/
			getMessage : function () /:String/ {
			return this.message + "\nExpected: " + this.expected + " (" + (typeof this.expected) + ")" +
			"\nActual:" + this.actual + " (" + (typeof this.actual) + ")";
			}

			});

			/**
			* UnexpectedValue is subclass of AssertionError that is thrown whenever
			* a value was unexpected in its scope. This typically means that a test
			* was performed to determine that a value was not equal to a certain
			* value.
			*
			* @param {String} message The message to display when the error occurs.
			* @param {Object} unexpected The unexpected value.
			* @namespace YAHOO.util
			* @extends YAHOO.util.AssertionError
			* @class UnexpectedValue
			* @constructor
			*/
			YAHOO.util.UnexpectedValue = function (message /:String/, unexpected /:Object/){

			//call superclass
			YAHOO.util.AssertionError.call(this, message);

			/**
			* The unexpected value.
			* @type Object
			* @property unexpected
			*/
			this.unexpected /:Object/ = unexpected;

			/**
			* The name of the error that occurred.
			* @type String
			* @property name
			*/
			this.name /:String/ = "UnexpectedValue";

			};

			//inherit methods
			YAHOO.lang.extend(YAHOO.util.UnexpectedValue, YAHOO.util.AssertionError, {

			/**
			* Returns a fully formatted error for an assertion failure. The message
			* contains information about the unexpected value that was encountered.
			* @method getMessage
			* @return {String} A string describing the error.
			*/
			getMessage : function () /:String/ {
			return this.message + "\nUnexpected: " + this.unexpected + " (" + (typeof this.unexpected) + ") ";
			}

			});

			/**
			* ShouldFail is subclass of AssertionError that is thrown whenever
			* a test was expected to fail but did not.
			*
			* @param {String} message The message to display when the error occurs.
			* @namespace YAHOO.util
			* @extends YAHOO.util.AssertionError
			* @class ShouldFail
			* @constructor
			*/
			YAHOO.util.ShouldFail = function (message /:String/){

			//call superclass
			YAHOO.util.AssertionError.call(this, message \|\| "This test should fail but didn't.");

			/**
			* The name of the error that occurred.
			* @type String
			* @property name
			*/
			this.name /:String/ = "ShouldFail";

			};

			//inherit methods
			YAHOO.lang.extend(YAHOO.util.ShouldFail, YAHOO.util.AssertionError);

			/**
			* ShouldError is subclass of AssertionError that is thrown whenever
			* a test is expected to throw an error but doesn't.
			*
			* @param {String} message The message to display when the error occurs.
			* @namespace YAHOO.util
			* @extends YAHOO.util.AssertionError
			* @class ShouldError
			* @constructor
			*/
			YAHOO.util.ShouldError = function (message /:String/){

			//call superclass
			YAHOO.util.AssertionError.call(this, message \|\| "This test should have thrown an error but didn't.");

			/**
			* The name of the error that occurred.
			* @type String
			* @property name
			*/
			this.name /:String/ = "ShouldError";

			};

			//inherit methods
			YAHOO.lang.extend(YAHOO.util.ShouldError, YAHOO.util.AssertionError);

			/**
			* UnexpectedError is subclass of AssertionError that is thrown whenever
			* an error occurs within the course of a test and the test was not expected
			* to throw an error.
			*
			* @param {Error} cause The unexpected error that caused this error to be
			* thrown.
			* @namespace YAHOO.util
			* @extends YAHOO.util.AssertionError
			* @class UnexpectedError
			* @constructor
			*/
			YAHOO.util.UnexpectedError = function (cause /:Object/){

			//call superclass
			YAHOO.util.AssertionError.call(this, "Unexpected error: " + cause.message);

			/**
			* The unexpected error that occurred.
			* @type Error
			* @property cause
			*/
			this.cause /:Error/ = cause;

			/**
			* The name of the error that occurred.
			* @type String
			* @property name
			*/
			this.name /:String/ = "UnexpectedError";

			/**
			* Stack information for the error (if provided).
			* @type String
			* @property stack
			*/
			this.stack /:String/ = cause.stack;

			};

			//inherit methods
			YAHOO.lang.extend(YAHOO.util.UnexpectedError, YAHOO.util.AssertionError);
			//-----------------------------------------------------------------------------
			// ArrayAssert object
			//-----------------------------------------------------------------------------

			/**
			* The ArrayAssert object provides functions to test JavaScript array objects
			* for a variety of cases.
			*
			* @namespace YAHOO.util
			* @class ArrayAssert
			* @static
			*/

			YAHOO.util.ArrayAssert = {

			/**
			* Asserts that a value is present in an array. This uses the triple equals
			* sign so no type cohersion may occur.
			* @param {Object} needle The value that is expected in the array.
			* @param {Array} haystack An array of values.
			* @param {String} message (Optional) The message to display if the assertion fails.
			* @method contains
			* @static
			*/
			contains : function (needle /:Object/, haystack /:Array/,
			message /:String/) /:Void/ {

			var found /:Boolean/ = false;
			var Assert = YAHOO.util.Assert;

			//begin checking values
			for (var i=0; i < haystack.length && !found; i++){
			if (haystack[i] === needle) {
			found = true;
			}
			}

			if (!found){
			Assert.fail(Assert._formatMessage(message, "Value " + needle + " (" + (typeof needle) + ") not found in array [" + haystack + "]."));
			}
			},

			/**
			* Asserts that a set of values are present in an array. This uses the triple equals
			* sign so no type cohersion may occur. For this assertion to pass, all values must
			* be found.
			* @param {Object[]} needles An array of values that are expected in the array.
			* @param {Array} haystack An array of values to check.
			* @param {String} message (Optional) The message to display if the assertion fails.
			* @method containsItems
			* @static
			*/
			containsItems : function (needles /:Object[]/, haystack /:Array/,
			message /:String/) /:Void/ {

			//begin checking values
			for (var i=0; i < needles.length; i++){
			this.contains(needles[i], haystack, message);
			}
			},

			/**
			* Asserts that a value matching some condition is present in an array. This uses
			* a function to determine a match.
			* @param {Function} matcher A function that returns true if the items matches or false if not.
			* @param {Array} haystack An array of values.
			* @param {String} message (Optional) The message to display if the assertion fails.
			* @method containsMatch
			* @static
			*/
			containsMatch : function (matcher /:Function/, haystack /:Array/,
			message /:String/) /:Void/ {

			//check for valid matcher
			if (typeof matcher != "function"){
			throw new TypeError("ArrayAssert.containsMatch(): First argument must be a function.");
			}

			var found /:Boolean/ = false;
			var Assert = YAHOO.util.Assert;

			//begin checking values
			for (var i=0; i < haystack.length && !found; i++){
			if (matcher(haystack[i])) {
			found = true;
			}
			}

			if (!found){
			Assert.fail(Assert._formatMessage(message, "No match found in array [" + haystack + "]."));
			}
			},

			/**
			* Asserts that a value is not present in an array. This uses the triple equals
			* sign so no type cohersion may occur.
			* @param {Object} needle The value that is expected in the array.
			* @param {Array} haystack An array of values.
			* @param {String} message (Optional) The message to display if the assertion fails.
			* @method doesNotContain
			* @static
			*/
			doesNotContain : function (needle /:Object/, haystack /:Array/,
			message /:String/) /:Void/ {

			var found /:Boolean/ = false;
			var Assert = YAHOO.util.Assert;

			//begin checking values
			for (var i=0; i < haystack.length && !found; i++){
			if (haystack[i] === needle) {
			found = true;
			}
			}

			if (found){
			Assert.fail(Assert._formatMessage(message, "Value found in array [" + haystack + "]."));
			}
			},

			/**
			* Asserts that a set of values are not present in an array. This uses the triple equals
			* sign so no type cohersion may occur. For this assertion to pass, all values must
			* not be found.
			* @param {Object[]} needles An array of values that are not expected in the array.
			* @param {Array} haystack An array of values to check.
			* @param {String} message (Optional) The message to display if the assertion fails.
			* @method doesNotContainItems
			* @static
			*/
			doesNotContainItems : function (needles /:Object[]/, haystack /:Array/,
			message /:String/) /:Void/ {

			for (var i=0; i < needles.length; i++){
			this.doesNotContain(needles[i], haystack, message);
			}

			},

			/**
			* Asserts that no values matching a condition are present in an array. This uses
			* a function to determine a match.
			* @param {Function} matcher A function that returns true if the items matches or false if not.
			* @param {Array} haystack An array of values.
			* @param {String} message (Optional) The message to display if the assertion fails.
			* @method doesNotContainMatch
			* @static
			*/
			doesNotContainMatch : function (matcher /:Function/, haystack /:Array/,
			message /:String/) /:Void/ {

			//check for valid matcher
			if (typeof matcher != "function"){
			throw new TypeError("ArrayAssert.doesNotContainMatch(): First argument must be a function.");
			}

			var found /:Boolean/ = false;
			var Assert = YAHOO.util.Assert;

			//begin checking values
			for (var i=0; i < haystack.length && !found; i++){
			if (matcher(haystack[i])) {
			found = true;
			}
			}

			if (found){
			Assert.fail(Assert._formatMessage(message, "Value found in array [" + haystack + "]."));
			}
			},

			/**
			* Asserts that the given value is contained in an array at the specified index.
			* This uses the triple equals sign so no type cohersion will occur.
			* @param {Object} needle The value to look for.
			* @param {Array} haystack The array to search in.
			* @param {int} index The index at which the value should exist.
			* @param {String} message (Optional) The message to display if the assertion fails.
			* @method indexOf
			* @static
			*/
			indexOf : function (needle /:Object/, haystack /:Array/, index /:int/, message /:String/) /:Void/ {

			//try to find the value in the array
			for (var i=0; i < haystack.length; i++){
			if (haystack[i] === needle){
			YAHOO.util.Assert.areEqual(index, i, message \|\| "Value exists at index " + i + " but should be at index " + index + ".");
			return;
			}
			}

			var Assert = YAHOO.util.Assert;

			//if it makes it here, it wasn't found at all
			Assert.fail(Assert._formatMessage(message, "Value doesn't exist in array [" + haystack + "]."));
			},

			/**
			* Asserts that the values in an array are equal, and in the same position,
			* as values in another array. This uses the double equals sign
			* so type cohersion may occur. Note that the array objects themselves
			* need not be the same for this test to pass.
			* @param {Array} expected An array of the expected values.
			* @param {Array} actual Any array of the actual values.
			* @param {String} message (Optional) The message to display if the assertion fails.
			* @method itemsAreEqual
			* @static
			*/
			itemsAreEqual : function (expected /:Array/, actual /:Array/,
			message /:String/) /:Void/ {

			//one may be longer than the other, so get the maximum length
			var len /:int/ = Math.max(expected.length, actual.length \|\| 0);
			var Assert = YAHOO.util.Assert;

			//begin checking values
			for (var i=0; i < len; i++){
			Assert.areEqual(expected[i], actual[i],
			Assert._formatMessage(message, "Values in position " + i + " are not equal."));
			}
			},

			/**
			* Asserts that the values in an array are equivalent, and in the same position,
			* as values in another array. This uses a function to determine if the values
			* are equivalent. Note that the array objects themselves
			* need not be the same for this test to pass.
			* @param {Array} expected An array of the expected values.
			* @param {Array} actual Any array of the actual values.
			* @param {Function} comparator A function that returns true if the values are equivalent
			* or false if not.
			* @param {String} message (Optional) The message to display if the assertion fails.
			* @return {Void}
			* @method itemsAreEquivalent
			* @static
			*/
			itemsAreEquivalent : function (expected /:Array/, actual /:Array/,
			comparator /:Function/, message /:String/) /:Void/ {

			//make sure the comparator is valid
			if (typeof comparator != "function"){
			throw new TypeError("ArrayAssert.itemsAreEquivalent(): Third argument must be a function.");
			}

			//one may be longer than the other, so get the maximum length
			var len /:int/ = Math.max(expected.length, actual.length \|\| 0);

			//begin checking values
			for (var i=0; i < len; i++){
			if (!comparator(expected[i], actual[i])){
			throw new YAHOO.util.ComparisonFailure(YAHOO.util.Assert._formatMessage(message, "Values in position " + i + " are not equivalent."), expected[i], actual[i]);
			}
			}
			},

			/**
			* Asserts that an array is empty.
			* @param {Array} actual The array to test.
			* @param {String} message (Optional) The message to display if the assertion fails.
			* @method isEmpty
			* @static
			*/
			isEmpty : function (actual /:Array/, message /:String/) /:Void/ {
			if (actual.length > 0){
			var Assert = YAHOO.util.Assert;
			Assert.fail(Assert._formatMessage(message, "Array should be empty."));
			}
			},

			/**
			* Asserts that an array is not empty.
			* @param {Array} actual The array to test.
			* @param {String} message (Optional) The message to display if the assertion fails.
			* @method isNotEmpty
			* @static
			*/
			isNotEmpty : function (actual /:Array/, message /:String/) /:Void/ {
			if (actual.length === 0){
			var Assert = YAHOO.util.Assert;
			Assert.fail(Assert._formatMessage(message, "Array should not be empty."));
			}
			},

			/**
			* Asserts that the values in an array are the same, and in the same position,
			* as values in another array. This uses the triple equals sign
			* so no type cohersion will occur. Note that the array objects themselves
			* need not be the same for this test to pass.
			* @param {Array} expected An array of the expected values.
			* @param {Array} actual Any array of the actual values.
			* @param {String} message (Optional) The message to display if the assertion fails.
			* @method itemsAreSame
			* @static
			*/
			itemsAreSame : function (expected /:Array/, actual /:Array/,
			message /:String/) /:Void/ {

			//one may be longer than the other, so get the maximum length
			var len /:int/ = Math.max(expected.length, actual.length \|\| 0);
			var Assert = YAHOO.util.Assert;

			//begin checking values
			for (var i=0; i < len; i++){
			Assert.areSame(expected[i], actual[i],
			Assert._formatMessage(message, "Values in position " + i + " are not the same."));
			}
			},

			/**
			* Asserts that the given value is contained in an array at the specified index,
			* starting from the back of the array.
			* This uses the triple equals sign so no type cohersion will occur.
			* @param {Object} needle The value to look for.
			* @param {Array} haystack The array to search in.
			* @param {int} index The index at which the value should exist.
			* @param {String} message (Optional) The message to display if the assertion fails.
			* @method lastIndexOf
			* @static
			*/
			lastIndexOf : function (needle /:Object/, haystack /:Array/, index /:int/, message /:String/) /:Void/ {

			var Assert = YAHOO.util.Assert;

			//try to find the value in the array
			for (var i=haystack.length; i >= 0; i--){
			if (haystack[i] === needle){
			Assert.areEqual(index, i, Assert._formatMessage(message, "Value exists at index " + i + " but should be at index " + index + "."));
			return;
			}
			}

			//if it makes it here, it wasn't found at all
			Assert.fail(Assert._formatMessage(message, "Value doesn't exist in array."));
			}

			};
			YAHOO.namespace("util");


			//-----------------------------------------------------------------------------
			// ObjectAssert object
			//-----------------------------------------------------------------------------

			/**
			* The ObjectAssert object provides functions to test JavaScript objects
			* for a variety of cases.
			*
			* @namespace YAHOO.util
			* @class ObjectAssert
			* @static
			*/
			YAHOO.util.ObjectAssert = {

			/**
			* Asserts that all properties in the object exist in another object.
			* @param {Object} expected An object with the expected properties.
			* @param {Object} actual An object with the actual properties.
			* @param {String} message (Optional) The message to display if the assertion fails.
			* @method propertiesAreEqual
			* @static
			*/
			propertiesAreEqual : function (expected /:Object/, actual /:Object/,
			message /:String/) /:Void/ {

			var Assert = YAHOO.util.Assert;

			//get all properties in the object
			var properties /:Array/ = [];
			for (var property in expected){
			properties.push(property);
			}

			//see if the properties are in the expected object
			for (var i=0; i < properties.length; i++){
			Assert.isNotUndefined(actual[properties[i]],
			Assert._formatMessage(message, "Property '" + properties[i] + "' expected."));
			}

			},

			/**
			* Asserts that an object has a property with the given name.
			* @param {String} propertyName The name of the property to test.
			* @param {Object} object The object to search.
			* @param {String} message (Optional) The message to display if the assertion fails.
			* @method hasProperty
			* @static
			*/
			hasProperty : function (propertyName /:String/, object /:Object/, message /:String/) /:Void/ {
			if (!(propertyName in object)){
			var Assert = YAHOO.util.Assert;
			Assert.fail(Assert._formatMessage(message, "Property '" + propertyName + "' not found on object."));
			}
			},

			/**
			* Asserts that a property with the given name exists on an object instance (not on its prototype).
			* @param {String} propertyName The name of the property to test.
			* @param {Object} object The object to search.
			* @param {String} message (Optional) The message to display if the assertion fails.
			* @method hasProperty
			* @static
			*/
			hasOwnProperty : function (propertyName /:String/, object /:Object/, message /:String/) /:Void/ {
			if (!YAHOO.lang.hasOwnProperty(object, propertyName)){
			var Assert = YAHOO.util.Assert;
			Assert.fail(Assert._formatMessage(message, "Property '" + propertyName + "' not found on object instance."));
			}
			}
			};
			//-----------------------------------------------------------------------------
			// DateAssert object
			//-----------------------------------------------------------------------------

			/**
			* The DateAssert object provides functions to test JavaScript Date objects
			* for a variety of cases.
			*
			* @namespace YAHOO.util
			* @class DateAssert
			* @static
			*/

			YAHOO.util.DateAssert = {

			/**
			* Asserts that a date's month, day, and year are equal to another date's.
			* @param {Date} expected The expected date.
			* @param {Date} actual The actual date to test.
			* @param {String} message (Optional) The message to display if the assertion fails.
			* @method datesAreEqual
			* @static
			*/
			datesAreEqual : function (expected /:Date/, actual /:Date/, message /:String/){
			if (expected instanceof Date && actual instanceof Date){
			var Assert = YAHOO.util.Assert;
			Assert.areEqual(expected.getFullYear(), actual.getFullYear(), Assert._formatMessage(message, "Years should be equal."));
			Assert.areEqual(expected.getMonth(), actual.getMonth(), Assert._formatMessage(message, "Months should be equal."));
			Assert.areEqual(expected.getDate(), actual.getDate(), Assert._formatMessage(message, "Day of month should be equal."));
			} else {
			throw new TypeError("DateAssert.datesAreEqual(): Expected and actual values must be Date objects.");
			}
			},

			/**
			* Asserts that a date's hour, minutes, and seconds are equal to another date's.
			* @param {Date} expected The expected date.
			* @param {Date} actual The actual date to test.
			* @param {String} message (Optional) The message to display if the assertion fails.
			* @method timesAreEqual
			* @static
			*/
			timesAreEqual : function (expected /:Date/, actual /:Date/, message /:String/){
			if (expected instanceof Date && actual instanceof Date){
			var Assert = YAHOO.util.Assert;
			Assert.areEqual(expected.getHours(), actual.getHours(), Assert._formatMessage(message, "Hours should be equal."));
			Assert.areEqual(expected.getMinutes(), actual.getMinutes(), Assert._formatMessage(message, "Minutes should be equal."));
			Assert.areEqual(expected.getSeconds(), actual.getSeconds(), Assert._formatMessage(message, "Seconds should be equal."));
			} else {
			throw new TypeError("DateAssert.timesAreEqual(): Expected and actual values must be Date objects.");
			}
			}

			};
			YAHOO.namespace("tool");

			//-----------------------------------------------------------------------------
			// TestManager object
			//-----------------------------------------------------------------------------

			/**
			* Runs pages containing test suite definitions.
			* @namespace YAHOO.tool
			* @class TestManager
			* @static
			*/
			YAHOO.tool.TestManager = {

			/**
			* Constant for the testpagebegin custom event
			* @property TEST_PAGE_BEGIN_EVENT
			* @static
			* @type string
			* @final
			*/
			TEST_PAGE_BEGIN_EVENT /:String/ : "testpagebegin",

			/**
			* Constant for the testpagecomplete custom event
			* @property TEST_PAGE_COMPLETE_EVENT
			* @static
			* @type string
			* @final
			*/
			TEST_PAGE_COMPLETE_EVENT /:String/ : "testpagecomplete",

			/**
			* Constant for the testmanagerbegin custom event
			* @property TEST_MANAGER_BEGIN_EVENT
			* @static
			* @type string
			* @final
			*/
			TEST_MANAGER_BEGIN_EVENT /:String/ : "testmanagerbegin",

			/**
			* Constant for the testmanagercomplete custom event
			* @property TEST_MANAGER_COMPLETE_EVENT
			* @static
			* @type string
			* @final
			*/
			TEST_MANAGER_COMPLETE_EVENT /:String/ : "testmanagercomplete",

			//-------------------------------------------------------------------------
			// Private Properties
			//-------------------------------------------------------------------------


			/**
			* The URL of the page currently being executed.
			* @type String
			* @private
			* @property _curPage
			* @static
			*/
			_curPage /:String/ : null,

			/**
			* The frame used to load and run tests.
			* @type Window
			* @private
			* @property _frame
			* @static
			*/
			_frame /:Window/ : null,

			/**
			* The logger used to output results from the various tests.
			* @type YAHOO.tool.TestLogger
			* @private
			* @property _logger
			* @static
			*/
			_logger : null,

			/**
			* The timeout ID for the next iteration through the tests.
			* @type int
			* @private
			* @property _timeoutId
			* @static
			*/
			_timeoutId /:int/ : 0,

			/**
			* Array of pages to load.
			* @type String[]
			* @private
			* @property _pages
			* @static
			*/
			_pages /:String[]/ : [],

			/**
			* Aggregated results
			* @type Object
			* @private
			* @property _results
			* @static
			*/
			_results: null,

			//-------------------------------------------------------------------------
			// Private Methods
			//-------------------------------------------------------------------------

			/**
			* Handles TestRunner.COMPLETE_EVENT, storing the results and beginning
			* the loop again.
			* @param {Object} data Data about the event.
			* @return {Void}
			* @private
			* @static
			*/
			_handleTestRunnerComplete : function (data /:Object/) /:Void/ {

			this.fireEvent(this.TEST_PAGE_COMPLETE_EVENT, {
			page: this._curPage,
			results: data.results
			});

			//save results
			//this._results[this.curPage] = data.results;

			//process 'em
			this._processResults(this._curPage, data.results);

			this._logger.clearTestRunner();

			//if there's more to do, set a timeout to begin again
			if (this._pages.length){
			this._timeoutId = setTimeout(function(){
			YAHOO.tool.TestManager._run();
			}, 1000);
			} else {
			this.fireEvent(this.TEST_MANAGER_COMPLETE_EVENT, this._results);
			}
			},

			/**
			* Processes the results of a test page run, outputting log messages
			* for failed tests.
			* @return {Void}
			* @private
			* @static
			*/
			_processResults : function (page /:String/, results /:Object/) /:Void/ {

			var r = this._results;

			r.passed += results.passed;
			r.failed += results.failed;
			r.ignored += results.ignored;
			r.total += results.total;
			r.duration += results.duration;

			if (results.failed){
			r.failedPages.push(page);
			} else {
			r.passedPages.push(page);
			}

			results.name = page;
			results.type = "page";

			r[page] = results;
			},

			/**
			* Loads the next test page into the iframe.
			* @return {Void}
			* @static
			* @private
			*/
			_run : function () /:Void/ {

			//set the current page
			this._curPage = this._pages.shift();

			this.fireEvent(this.TEST_PAGE_BEGIN_EVENT, this._curPage);

			//load the frame - destroy history in case there are other iframes that
			//need testing
			this._frame.location.replace(this._curPage);

			},

			//-------------------------------------------------------------------------
			// Public Methods
			//-------------------------------------------------------------------------

			/**
			* Signals that a test page has been loaded. This should be called from
			* within the test page itself to notify the TestManager that it is ready.
			* @return {Void}
			* @static
			*/
			load : function () /:Void/ {
			if (parent.YAHOO.tool.TestManager !== this){
			parent.YAHOO.tool.TestManager.load();
			} else {

			if (this._frame) {
			//assign event handling
			var TestRunner = this._frame.YAHOO.tool.TestRunner;

			this._logger.setTestRunner(TestRunner);
			TestRunner.subscribe(TestRunner.COMPLETE_EVENT, this._handleTestRunnerComplete, this, true);

			//run it
			TestRunner.run();
			}
			}
			},

			/**
			* Sets the pages to be loaded.
			* @param {String[]} pages An array of URLs to load.
			* @return {Void}
			* @static
			*/
			setPages : function (pages /:String[]/) /:Void/ {
			this._pages = pages;
			},

			/**
			* Begins the process of running the tests.
			* @return {Void}
			* @static
			*/
			start : function () /:Void/ {

			if (!this._initialized) {

			/**
			* Fires when loading a test page
			* @event testpagebegin
			* @param curPage {string} the page being loaded
			* @static
			*/
			this.createEvent(this.TEST_PAGE_BEGIN_EVENT);

			/**
			* Fires when a test page is complete
			* @event testpagecomplete
			* @param obj {page: string, results: object} the name of the
			* page that was loaded, and the test suite results
			* @static
			*/
			this.createEvent(this.TEST_PAGE_COMPLETE_EVENT);

			/**
			* Fires when the test manager starts running all test pages
			* @event testmanagerbegin
			* @static
			*/
			this.createEvent(this.TEST_MANAGER_BEGIN_EVENT);

			/**
			* Fires when the test manager finishes running all test pages. External
			* test runners should subscribe to this event in order to get the
			* aggregated test results.
			* @event testmanagercomplete
			* @param obj { pages_passed: int, pages_failed: int, tests_passed: int
			* tests_failed: int, passed: string[], failed: string[],
			* page_results: {} }
			* @static
			*/
			this.createEvent(this.TEST_MANAGER_COMPLETE_EVENT);

			//create iframe if not already available
			if (!this._frame){
			var frame /:HTMLElement/ = document.createElement("iframe");
			frame.style.visibility = "hidden";
			frame.style.position = "absolute";
			document.body.appendChild(frame);
			this._frame = frame.contentWindow \|\| frame.contentDocument.parentWindow;
			}

			//create test logger if not already available
			if (!this._logger){
			this._logger = new YAHOO.tool.TestLogger();
			}

			this._initialized = true;
			}


			// reset the results cache
			this._results = {

			passed: 0,
			failed: 0,
			ignored: 0,
			total: 0,
			type: "report",
			name: "YUI Test Results",
			duration: 0,
			failedPages:[],
			passedPages:[]
			/*
			// number of pages that pass
			pages_passed: 0,
			// number of pages that fail
			pages_failed: 0,
			// total number of tests passed
			tests_passed: 0,
			// total number of tests failed
			tests_failed: 0,
			// array of pages that passed
			passed: [],
			// array of pages that failed
			failed: [],
			// map of full results for each page
			page_results: {}*/
			};

			this.fireEvent(this.TEST_MANAGER_BEGIN_EVENT, null);
			this._run();

			},

			/**
			* Stops the execution of tests.
			* @return {Void}
			* @static
			*/
			stop : function () /:Void/ {
			clearTimeout(this._timeoutId);
			}

			};

			YAHOO.lang.augmentObject(YAHOO.tool.TestManager, YAHOO.util.EventProvider.prototype);

			YAHOO.namespace("tool");

			//-----------------------------------------------------------------------------
			// TestLogger object
			//-----------------------------------------------------------------------------

			/**
			* Displays test execution progress and results, providing filters based on
			* different key events.
			* @namespace YAHOO.tool
			* @class TestLogger
			* @constructor
			* @param {HTMLElement} element (Optional) The element to create the logger in.
			* @param {Object} config (Optional) Configuration options for the logger.
			*/
			YAHOO.tool.TestLogger = function (element, config) {
			YAHOO.tool.TestLogger.superclass.constructor.call(this, element, config);
			this.init();
			};

			YAHOO.lang.extend(YAHOO.tool.TestLogger, YAHOO.widget.LogReader, {

			footerEnabled : true,
			newestOnTop : false,

			/**
			* Formats message string to HTML for output to console.
			* @private
			* @method formatMsg
			* @param oLogMsg {Object} Log message object.
			* @return {String} HTML-formatted message for output to console.
			*/
			formatMsg : function(message /:Object/) {

			var category /:String/ = message.category;
			var text /:String/ = this.html2Text(message.msg);

			return "<pre><p><span class=\"" + category + "\">" + category.toUpperCase() + "</span> " + text + "</p></pre>";

			},

			//-------------------------------------------------------------------------
			// Private Methods
			//-------------------------------------------------------------------------

			/*
			* Initializes the logger.
			* @private
			*/
			init : function () {

			//attach to any available TestRunner
			if (YAHOO.tool.TestRunner){
			this.setTestRunner(YAHOO.tool.TestRunner);
			}

			//hide useless sources
			this.hideSource("global");
			this.hideSource("LogReader");

			//hide useless message categories
			this.hideCategory("warn");
			this.hideCategory("window");
			this.hideCategory("time");

			//reset the logger
			this.clearConsole();
			},

			/**
			* Clears the reference to the TestRunner from previous operations. This
			* unsubscribes all events and removes the object reference.
			* @return {Void}
			* @static
			*/
			clearTestRunner : function () /:Void/ {
			if (this._runner){
			this._runner.unsubscribeAll();
			this._runner = null;
			}
			},

			/**
			* Sets the source test runner that the logger should monitor.
			* @param {YAHOO.tool.TestRunner} testRunner The TestRunner to observe.
			* @return {Void}
			* @static
			*/
			setTestRunner : function (testRunner /:YAHOO.tool.TestRunner/) /:Void/ {

			if (this._runner){
			this.clearTestRunner();
			}

			this._runner = testRunner;

			//setup event _handlers
			testRunner.subscribe(testRunner.TEST_PASS_EVENT, this._handleTestRunnerEvent, this, true);
			testRunner.subscribe(testRunner.TEST_FAIL_EVENT, this._handleTestRunnerEvent, this, true);
			testRunner.subscribe(testRunner.TEST_IGNORE_EVENT, this._handleTestRunnerEvent, this, true);
			testRunner.subscribe(testRunner.BEGIN_EVENT, this._handleTestRunnerEvent, this, true);
			testRunner.subscribe(testRunner.COMPLETE_EVENT, this._handleTestRunnerEvent, this, true);
			testRunner.subscribe(testRunner.TEST_SUITE_BEGIN_EVENT, this._handleTestRunnerEvent, this, true);
			testRunner.subscribe(testRunner.TEST_SUITE_COMPLETE_EVENT, this._handleTestRunnerEvent, this, true);
			testRunner.subscribe(testRunner.TEST_CASE_BEGIN_EVENT, this._handleTestRunnerEvent, this, true);
			testRunner.subscribe(testRunner.TEST_CASE_COMPLETE_EVENT, this._handleTestRunnerEvent, this, true);
			},

			//-------------------------------------------------------------------------
			// Event Handlers
			//-------------------------------------------------------------------------

			/**
			* Handles all TestRunner events, outputting appropriate data into the console.
			* @param {Object} data The event data object.
			* @return {Void}
			* @private
			*/
			_handleTestRunnerEvent : function (data /:Object/) /:Void/ {

			//shortcut variables
			var TestRunner /:Object/ = YAHOO.tool.TestRunner;

			//data variables
			var message /:String/ = "";
			var messageType /:String/ = "";

			switch(data.type){
			case TestRunner.BEGIN_EVENT:
			message = "Testing began at " + (new Date()).toString() + ".";
			messageType = "info";
			break;

			case TestRunner.COMPLETE_EVENT:
			message = "Testing completed at " + (new Date()).toString() + ".\nPassed:" +
			data.results.passed + " Failed:" + data.results.failed + " Total:" + data.results.total;
			messageType = "info";
			break;

			case TestRunner.TEST_FAIL_EVENT:
			message = data.testName + ": " + data.error.getMessage();
			messageType = "fail";
			break;

			case TestRunner.TEST_IGNORE_EVENT:
			message = data.testName + ": ignored.";
			messageType = "ignore";
			break;

			case TestRunner.TEST_PASS_EVENT:
			message = data.testName + ": passed.";
			messageType = "pass";
			break;

			case TestRunner.TEST_SUITE_BEGIN_EVENT:
			message = "Test suite \"" + data.testSuite.name + "\" started.";
			messageType = "info";
			break;

			case TestRunner.TEST_SUITE_COMPLETE_EVENT:
			message = "Test suite \"" + data.testSuite.name + "\" completed.\nPassed:" +
			data.results.passed + " Failed:" + data.results.failed + " Total:" + data.results.total;
			messageType = "info";
			break;

			case TestRunner.TEST_CASE_BEGIN_EVENT:
			message = "Test case \"" + data.testCase.name + "\" started.";
			messageType = "info";
			break;

			case TestRunner.TEST_CASE_COMPLETE_EVENT:
			message = "Test case \"" + data.testCase.name + "\" completed.\nPassed:" +
			data.results.passed + " Failed:" + data.results.failed + " Total:" + data.results.total;
			messageType = "info";
			break;
			default:
			message = "Unexpected event " + data.type;
			message = "info";
			}

			YAHOO.log(message, messageType, "TestRunner");
			}

			});
			YAHOO.namespace("tool.TestFormat");

			/**
			* Returns test results formatted as a JSON string. Requires JSON utility.
			* @param {Object} result The results object created by TestRunner.
			* @return {String} An XML-formatted string of results.
			* @namespace YAHOO.tool.TestFormat
			* @method JSON
			* @static
			*/
			YAHOO.tool.TestFormat.JSON = function(results /:Object/) /:String/ {
			return YAHOO.lang.JSON.stringify(results);
			};

			/**
			* Returns test results formatted as an XML string.
			* @param {Object} result The results object created by TestRunner.
			* @return {String} An XML-formatted string of results.
			* @namespace YAHOO.tool.TestFormat
			* @method XML
			* @static
			*/
			YAHOO.tool.TestFormat.XML = function(results /:Object/) /:String/ {

			var l = YAHOO.lang;
			var xml /:String/ = "<" + results.type + " name=\"" + results.name.replace(/"/g, """).replace(/'/g, "'") + "\"";

			if (l.isNumber(results.duration)){
			xml += " duration=\"" + results.duration + "\"";
			}

			if (results.type == "test"){
			xml += " result=\"" + results.result + "\" message=\"" + results.message + "\">";
			} else {
			xml += " passed=\"" + results.passed + "\" failed=\"" + results.failed + "\" ignored=\"" + results.ignored + "\" total=\"" + results.total + "\">";
			for (var prop in results) {
			if (l.hasOwnProperty(results, prop) && l.isObject(results[prop]) && !l.isArray(results[prop])){
			xml += arguments.callee(results[prop]);
			}
			}
			}

			xml += "</" + results.type + ">";

			return xml;

			};
			YAHOO.namespace("tool");

			/**
			* An object capable of sending test results to a server.
			* @param {String} url The URL to submit the results to.
			* @param {Function} format (Optiona) A function that outputs the results in a specific format.
			* Default is YAHOO.tool.TestFormat.XML.
			* @constructor
			* @namespace YAHOO.tool
			* @class TestReporter
			*/
			YAHOO.tool.TestReporter = function(url /:String/, format /:Function/) {

			/**
			* The URL to submit the data to.
			* @type String
			* @property url
			*/
			this.url /:String/ = url;

			/**
			* The formatting function to call when submitting the data.
			* @type Function
			* @property format
			*/
			this.format /:Function/ = format \|\| YAHOO.tool.TestFormat.XML;

			/**
			* Extra fields to submit with the request.
			* @type Object
			* @property _fields
			* @private
			*/
			this._fields /:Object/ = new Object();

			/**
			* The form element used to submit the results.
			* @type HTMLFormElement
			* @property _form
			* @private
			*/
			this._form /:HTMLElement/ = null;

			/**
			* Iframe used as a target for form submission.
			* @type HTMLIFrameElement
			* @property _iframe
			* @private
			*/
			this._iframe /:HTMLElement/ = null;
			};

			YAHOO.tool.TestReporter.prototype = {

			//restore missing constructor
			constructor: YAHOO.tool.TestReporter,

			/**
			* Convert a date into ISO format.
			* From Douglas Crockford's json2.js
			* @param {Date} date The date to convert.
			* @return {String} An ISO-formatted date string
			* @method _convertToISOString
			* @private
			*/
			_convertToISOString: function(date){
			function f(n) {
			// Format integers to have at least two digits.
			return n < 10 ? '0' + n : n;
			}

			return date.getUTCFullYear() + '-' +
			f(date.getUTCMonth() + 1) + '-' +
			f(date.getUTCDate()) + 'T' +
			f(date.getUTCHours()) + ':' +
			f(date.getUTCMinutes()) + ':' +
			f(date.getUTCSeconds()) + 'Z';

			},

			/**
			* Adds a field to the form that submits the results.
			* @param {String} name The name of the field.
			* @param {Variant} value The value of the field.
			* @return {Void}
			* @method addField
			*/
			addField : function (name /:String/, value /:Variant/) /:Void/{
			this._fields[name] = value;
			},

			/**
			* Removes all previous defined fields.
			* @return {Void}
			* @method addField
			*/
			clearFields : function() /:Void/{
			this._fields = new Object();
			},

			/**
			* Cleans up the memory associated with the TestReporter, removing DOM elements
			* that were created.
			* @return {Void}
			* @method destroy
			*/
			destroy : function() /:Void/ {
			if (this._form){
			this._form.parentNode.removeChild(this._form);
			this._form = null;
			}
			if (this._iframe){
			this._iframe.parentNode.removeChild(this._iframe);
			this._iframe = null;
			}
			this._fields = null;
			},

			/**
			* Sends the report to the server.
			* @param {Object} results The results object created by TestRunner.
			* @return {Void}
			* @method report
			*/
			report : function(results /:Object/) /:Void/{

			//if the form hasn't been created yet, create it
			if (!this._form){
			this._form = document.createElement("form");
			this._form.method = "post";
			this._form.style.visibility = "hidden";
			this._form.style.position = "absolute";
			this._form.style.top = 0;
			document.body.appendChild(this._form);

			//IE won't let you assign a name using the DOM, must do it the hacky way
			if (YAHOO.env.ua.ie){
			this._iframe = document.createElement("<iframe name=\"yuiTestTarget\" />");
			} else {
			this._iframe = document.createElement("iframe");
			this._iframe.name = "yuiTestTarget";
			}

			this._iframe.src = "javascript:false";
			this._iframe.style.visibility = "hidden";
			this._iframe.style.position = "absolute";
			this._iframe.style.top = 0;
			document.body.appendChild(this._iframe);

			this._form.target = "yuiTestTarget";
			}

			//set the form's action
			this._form.action = this.url;

			//remove any existing fields
			while(this._form.hasChildNodes()){
			this._form.removeChild(this._form.lastChild);
			}

			//create default fields
			this._fields.results = this.format(results);
			this._fields.useragent = navigator.userAgent;
			this._fields.timestamp = this._convertToISOString(new Date());

			//add fields to the form
			for (var prop in this._fields){
			if (YAHOO.lang.hasOwnProperty(this._fields, prop) && typeof this._fields[prop] != "function"){
			if (YAHOO.env.ua.ie){
			input = document.createElement("<input name=\"" + prop + "\" >");
			} else {
			input = document.createElement("input");
			input.name = prop;
			}
			input.type = "hidden";
			input.value = this._fields[prop];
			this._form.appendChild(input);
			}
			}

			//remove default fields
			delete this._fields.results;
			delete this._fields.useragent;
			delete this._fields.timestamp;

			if (arguments[1] !== false){
			this._form.submit();
			}

			}

			};
			YAHOO.register("yuitest", YAHOO.tool.TestRunner, {version: "2.8.2r1", build: "7"});

shrine-medco/shrine-webclient/src/main/html/js-ext/yui/build/yuitest/yuitest.js0e73872ba51ahotfix/1.21.2

yuitest.jsView Options

shrine-medco/shrine-webclient/src/main/html/js-ext/yui/build/yuitest/yuitest.js
0e73872ba51ahotfix/1.21.2

yuitest.js
View Options