samples/reviews/minitestrunner.js - external/bidichecker - Git at Google

 // Copyright 2010 Google Inc. All Rights Reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //      http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS-IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.

 /**
  * @fileoverview A quick-and-dirty miniature unit test runner, modeled only very
  * loosely after the style of xUnit. This is *not* - repeat: *not* - intended
  * for production use, anywhere. It is included here solely for the purpose of
  * demonstrating how to write unit test suites which use BidiChecker. It is not
  * robust, not full-featured, not well-tested, and most definitely not
  * supported! Real unit test suites for production systems (with or without
  * BidiChecker) should use a production-quality test framework. The best known
  * for JavaScript is JSUnit, but many alternatives are available, most of which
  * are free and open source. We do not use them in our samples to avoid adding
  * an external dependency.
  */

 /**
  * Common setup function to be run after each unit test. Undefined by default.
  * User code can replace it with a real function.
  * @type {Function|undefined}
  */
 var setUp = undefined;

 /**
  * Common cleanup function to be run after each unit test. Undefined by default.
  * User code can replace it with a real function.
  * @type {Function|undefined}
  */
 var tearDown = undefined;

 /**
  * Asserts that the actual value is equal to its expected value, or else throws
  * an exception constituting a string describing the mismatch. This function is
  * not meant to be robust; it is not guaranteed to work on any but simple types.
  * @param {*} expected The expected value.
  * @param {*} actual The actual value.
  */
 function assertEquals(expected, actual) {
   if (expected !== actual) {
     throw 'Expected ' + expected + ', got ' + actual;
   }
 }

 /**
  * Asserts that the actual contents of an array are equal to its expected
  * contents. This function is not meant to be robust; it is not guaranteed to
  * work on any but simple types.
  * @param {Array.<Object>} expected Expected array of values.
  * @param {Array.<Object>} actual Actal array of values.
  */
 function assertArrayEquals(expected, actual) {
   assertEquals(expected.length, actual.length);
   for (var i = 0; i < expected.length; i++) {
     assertEquals(expected[i], actual[i]);
   }
 }

 /**
  * Runs all the test functions (names start with "test") in the global
  * namespace. If defined, {@code setUp()} is called before each test function
  * and {@code tearDown} is called after. A summary of how many tests were run,
  * how many passed and how many failed is rendered to the page element with the
  * id "test_runner", as well as a list of which test functions passed and
  * failed. This function is designed to be called only once. It should be
  * invoked by a mechanism such as {@code <body onload="runTests()">} so that it
  * runs each time the page is refreshed.
  */
 function runTests() {
   var testRunnerElement = document.getElementById('test_runner');
   var resultsSummaryElement = createResultsSummaryElement_(testRunnerElement);
   var testResultsElement = createTestResultsElement_(testRunnerElement);

   var testFunctions = findTestFunctions_();
   var numFailed = 0;
   for (var i = 0; i < testFunctions.length; i++) {
     var testFunction = window[testFunctions[i]];
     var errorText = runOneTest_(testFunction);
     if (errorText != '') {
       numFailed++;
     }

     addResultEntry_(testResultsElement, testFunction.name, errorText);
     updateResultsSummary_(resultsSummaryElement, i + 1, numFailed);
   }
 }

 /**
  * Finds all global functions whose names start with "test".
  * @return {!Array.<string>} The names of the functions.
  * @private
  */
 function findTestFunctions_() {
   var testFunctionNames = [];
   for (var identifier in window) {
     if (identifier.substr(0, 4) == 'test' &&
         typeof(window[identifier]) == 'function') {
       testFunctionNames.push(identifier);
     }
   }
   testFunctionNames.sort();
   return testFunctionNames;
 }

 /**
  * Creates a DOM element to hold the results summary line.
  * @param {Element} parent The parent element.
  * @return {Element} The newly created element.
  * @private
  */
 function createResultsSummaryElement_(parent) {
   var resultsSummaryElement = document.createElement('h1');
   resultsSummaryElement.appendChild(document.createTextNode(''));
   parent.appendChild(resultsSummaryElement);
   return resultsSummaryElement;
 }

 /**
  * Creates a DOM element to hold the individual test result entries.
  * @param {Element} parent The parent element.
  * @return {Element} The newly created element.
  * @private
  */
 function createTestResultsElement_(parent) {
   var testResultsElement = document.createElement('p');
   parent.appendChild(testResultsElement);
   return testResultsElement;
 }

 /**
  * Runs a single test function, sandwiched by {@code setUp()} and
  * {@code tearDown} if defined.
  * @param {Function} testFunction The test function to be run.
  * @return {string} An empty string for succes; otherwise, the error message.
  * @private
  */
 function runOneTest_(testFunction) {
   try {
     if (setUp != undefined) {
       setUp();
     }
     testFunction();
     if (tearDown != undefined) {
       tearDown();
     }
   } catch (exception) {
     return exception;
   }
   return '';
 }

 /**
  * Adds a DOM element containing the results of a single test.
  * @param {Element} parent The parent element.
  * @param {string} testName The name of the test function.
  * @param {string} errorText Error message generated by the test, or blank.
  * @private
  */
 function addResultEntry_(parent, testName, errorText) {
   var newEntry = document.createElement('div');
   var description = testName +
       (errorText == '' ? ' passed' : ' failed: ' + errorText);
   newEntry.appendChild(document.createTextNode(description));
   var descriptionColor = errorText == '' ? 'green' : 'red';
   newEntry.setAttribute('style', 'color: ' + descriptionColor);
   parent.appendChild(newEntry);
 }

 /**
  * Updates the test results summary line with the result of a single test.
  * @param {Element} parent The parent element.
  * @param {number} numTests The number of tests run so far.
  * @param {number} numFailed The number of failing tests so far.
  * @private
  */
 function updateResultsSummary_(parent, numTests, numFailed) {
   var summaryText = 'Ran ' + numTests + ' tests: ' + (numTests - numFailed) +
       ' passed, ' + numFailed + ' failed.';

   var resultsColor = numFailed > 0 ? 'red' : 'green';
   parent.setAttribute('style', 'color: ' + resultsColor);
   parent.replaceChild(document.createTextNode(summaryText), parent.firstChild);
 }
	// Copyright 2010 Google Inc. All Rights Reserved.
	//
	// Licensed under the Apache License, Version 2.0 (the "License");
	// you may not use this file except in compliance with the License.
	// You may obtain a copy of the License at
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing, software
	// distributed under the License is distributed on an "AS-IS" BASIS,
	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	// See the License for the specific language governing permissions and
	// limitations under the License.

	/**
	* @fileoverview A quick-and-dirty miniature unit test runner, modeled only very
	* loosely after the style of xUnit. This is not - repeat: not - intended
	* for production use, anywhere. It is included here solely for the purpose of
	* demonstrating how to write unit test suites which use BidiChecker. It is not
	* robust, not full-featured, not well-tested, and most definitely not
	* supported! Real unit test suites for production systems (with or without
	* BidiChecker) should use a production-quality test framework. The best known
	* for JavaScript is JSUnit, but many alternatives are available, most of which
	* are free and open source. We do not use them in our samples to avoid adding
	* an external dependency.
	*/

	/**
	* Common setup function to be run after each unit test. Undefined by default.
	* User code can replace it with a real function.
	* @type {Function\|undefined}
	*/
	var setUp = undefined;

	/**
	* Common cleanup function to be run after each unit test. Undefined by default.
	* User code can replace it with a real function.
	* @type {Function\|undefined}
	*/
	var tearDown = undefined;

	/**
	* Asserts that the actual value is equal to its expected value, or else throws
	* an exception constituting a string describing the mismatch. This function is
	* not meant to be robust; it is not guaranteed to work on any but simple types.
	* @param {*} expected The expected value.
	* @param {*} actual The actual value.
	*/
	function assertEquals(expected, actual) {
	if (expected !== actual) {
	throw 'Expected ' + expected + ', got ' + actual;
	}
	}

	/**
	* Asserts that the actual contents of an array are equal to its expected
	* contents. This function is not meant to be robust; it is not guaranteed to
	* work on any but simple types.
	* @param {Array.<Object>} expected Expected array of values.
	* @param {Array.<Object>} actual Actal array of values.
	*/
	function assertArrayEquals(expected, actual) {
	assertEquals(expected.length, actual.length);
	for (var i = 0; i < expected.length; i++) {
	assertEquals(expected[i], actual[i]);
	}
	}

	/**
	* Runs all the test functions (names start with "test") in the global
	* namespace. If defined, {@code setUp()} is called before each test function
	* and {@code tearDown} is called after. A summary of how many tests were run,
	* how many passed and how many failed is rendered to the page element with the
	* id "test_runner", as well as a list of which test functions passed and
	* failed. This function is designed to be called only once. It should be
	* invoked by a mechanism such as {@code <body onload="runTests()">} so that it
	* runs each time the page is refreshed.
	*/
	function runTests() {
	var testRunnerElement = document.getElementById('test_runner');
	var resultsSummaryElement = createResultsSummaryElement_(testRunnerElement);
	var testResultsElement = createTestResultsElement_(testRunnerElement);

	var testFunctions = findTestFunctions_();
	var numFailed = 0;
	for (var i = 0; i < testFunctions.length; i++) {
	var testFunction = window[testFunctions[i]];
	var errorText = runOneTest_(testFunction);
	if (errorText != '') {
	numFailed++;
	}

	addResultEntry_(testResultsElement, testFunction.name, errorText);
	updateResultsSummary_(resultsSummaryElement, i + 1, numFailed);
	}
	}

	/**
	* Finds all global functions whose names start with "test".
	* @return {!Array.<string>} The names of the functions.
	* @private
	*/
	function findTestFunctions_() {
	var testFunctionNames = [];
	for (var identifier in window) {
	if (identifier.substr(0, 4) == 'test' &&
	typeof(window[identifier]) == 'function') {
	testFunctionNames.push(identifier);
	}
	}
	testFunctionNames.sort();
	return testFunctionNames;
	}

	/**
	* Creates a DOM element to hold the results summary line.
	* @param {Element} parent The parent element.
	* @return {Element} The newly created element.
	* @private
	*/
	function createResultsSummaryElement_(parent) {
	var resultsSummaryElement = document.createElement('h1');
	resultsSummaryElement.appendChild(document.createTextNode(''));
	parent.appendChild(resultsSummaryElement);
	return resultsSummaryElement;
	}

	/**
	* Creates a DOM element to hold the individual test result entries.
	* @param {Element} parent The parent element.
	* @return {Element} The newly created element.
	* @private
	*/
	function createTestResultsElement_(parent) {
	var testResultsElement = document.createElement('p');
	parent.appendChild(testResultsElement);
	return testResultsElement;
	}

	/**
	* Runs a single test function, sandwiched by {@code setUp()} and
	* {@code tearDown} if defined.
	* @param {Function} testFunction The test function to be run.
	* @return {string} An empty string for succes; otherwise, the error message.
	* @private
	*/
	function runOneTest_(testFunction) {
	try {
	if (setUp != undefined) {
	setUp();
	}
	testFunction();
	if (tearDown != undefined) {
	tearDown();
	}
	} catch (exception) {
	return exception;
	}
	return '';
	}

	/**
	* Adds a DOM element containing the results of a single test.
	* @param {Element} parent The parent element.
	* @param {string} testName The name of the test function.
	* @param {string} errorText Error message generated by the test, or blank.
	* @private
	*/
	function addResultEntry_(parent, testName, errorText) {
	var newEntry = document.createElement('div');
	var description = testName +
	(errorText == '' ? ' passed' : ' failed: ' + errorText);
	newEntry.appendChild(document.createTextNode(description));
	var descriptionColor = errorText == '' ? 'green' : 'red';
	newEntry.setAttribute('style', 'color: ' + descriptionColor);
	parent.appendChild(newEntry);
	}

	/**
	* Updates the test results summary line with the result of a single test.
	* @param {Element} parent The parent element.
	* @param {number} numTests The number of tests run so far.
	* @param {number} numFailed The number of failing tests so far.
	* @private
	*/
	function updateResultsSummary_(parent, numTests, numFailed) {
	var summaryText = 'Ran ' + numTests + ' tests: ' + (numTests - numFailed) +
	' passed, ' + numFailed + ' failed.';

	var resultsColor = numFailed > 0 ? 'red' : 'green';
	parent.setAttribute('style', 'color: ' + resultsColor);
	parent.replaceChild(document.createTextNode(summaryText), parent.firstChild);
	}