61c6ab3fb0
functional tests, unless a whole lot of mock objects are introduced, which isn't entirely out of the question). Uses JsUnit, which is included in this commit.
706 lines
24 KiB
JavaScript
706 lines
24 KiB
JavaScript
function jsUnitTestManager() {
|
|
this._windowForAllProblemMessages = null;
|
|
|
|
this.container = top.frames.testContainer
|
|
this.documentLoader = top.frames.documentLoader;
|
|
this.mainFrame = top.frames.mainFrame;
|
|
|
|
this.containerController = this.container.frames.testContainerController;
|
|
this.containerTestFrame = this.container.frames.testFrame;
|
|
|
|
var mainData = this.mainFrame.frames.mainData;
|
|
|
|
// form elements on mainData frame
|
|
this.testFileName = mainData.document.testRunnerForm.testFileName;
|
|
this.runButton = mainData.document.testRunnerForm.runButton;
|
|
this.traceLevel = mainData.document.testRunnerForm.traceLevel;
|
|
this.closeTraceWindowOnNewRun = mainData.document.testRunnerForm.closeTraceWindowOnNewRun;
|
|
this.timeout = mainData.document.testRunnerForm.timeout;
|
|
this.setUpPageTimeout = mainData.document.testRunnerForm.setUpPageTimeout;
|
|
|
|
// image output
|
|
this.progressBar = this.mainFrame.frames.mainProgress.document.progress;
|
|
|
|
this.problemsListField = this.mainFrame.frames.mainErrors.document.testRunnerForm.problemsList;
|
|
this.testCaseResultsField = this.mainFrame.frames.mainResults.document.resultsForm.testCases;
|
|
this.resultsTimeField = this.mainFrame.frames.mainResults.document.resultsForm.time;
|
|
|
|
// 'layer' output frames
|
|
this.uiFrames = new Object();
|
|
this.uiFrames.mainStatus = this.mainFrame.frames.mainStatus;
|
|
|
|
var mainCounts = this.mainFrame.frames.mainCounts;
|
|
|
|
this.uiFrames.mainCountsErrors = mainCounts.frames.mainCountsErrors;
|
|
this.uiFrames.mainCountsFailures = mainCounts.frames.mainCountsFailures;
|
|
this.uiFrames.mainCountsRuns = mainCounts.frames.mainCountsRuns;
|
|
this._baseURL = "";
|
|
|
|
this.setup();
|
|
}
|
|
|
|
// seconds to wait for each test page to load
|
|
jsUnitTestManager.TESTPAGE_WAIT_SEC = 120;
|
|
jsUnitTestManager.TIMEOUT_LENGTH = 20;
|
|
|
|
// seconds to wait for setUpPage to complete
|
|
jsUnitTestManager.SETUPPAGE_TIMEOUT = 120;
|
|
|
|
// milliseconds to wait between polls on setUpPages
|
|
jsUnitTestManager.SETUPPAGE_INTERVAL = 100;
|
|
|
|
jsUnitTestManager.RESTORED_HTML_DIV_ID = "jsUnitRestoredHTML";
|
|
|
|
jsUnitTestManager.prototype.setup = function () {
|
|
this.totalCount = 0;
|
|
this.errorCount = 0;
|
|
this.failureCount = 0;
|
|
this._suiteStack = Array();
|
|
|
|
var initialSuite = new top.jsUnitTestSuite();
|
|
push(this._suiteStack, initialSuite);
|
|
}
|
|
|
|
jsUnitTestManager.prototype.start = function () {
|
|
this._baseURL = this.resolveUserEnteredTestFileName();
|
|
var firstQuery = this._baseURL.indexOf("?");
|
|
if (firstQuery >= 0) {
|
|
this._baseURL = this._baseURL.substring(0, firstQuery);
|
|
}
|
|
var lastSlash = this._baseURL.lastIndexOf("/");
|
|
var lastRevSlash = this._baseURL.lastIndexOf("\\");
|
|
if (lastRevSlash > lastSlash) {
|
|
lastSlash = lastRevSlash;
|
|
}
|
|
if (lastSlash > 0) {
|
|
this._baseURL = this._baseURL.substring(0, lastSlash + 1);
|
|
}
|
|
|
|
this._timeRunStarted = new Date();
|
|
this.initialize();
|
|
setTimeout('top.testManager._nextPage();', jsUnitTestManager.TIMEOUT_LENGTH);
|
|
}
|
|
|
|
jsUnitTestManager.prototype.getBaseURL = function () {
|
|
return this._baseURL;
|
|
}
|
|
|
|
jsUnitTestManager.prototype.doneLoadingPage = function (pageName) {
|
|
//this.containerTestFrame.setTracer(top.tracer);
|
|
this._testFileName = pageName;
|
|
if (this.isTestPageSuite())
|
|
this._handleNewSuite();
|
|
else
|
|
{
|
|
this._testIndex = 0;
|
|
this._testsInPage = this.getTestFunctionNames();
|
|
this._numberOfTestsInPage = this._testsInPage.length;
|
|
this._runTest();
|
|
}
|
|
}
|
|
|
|
jsUnitTestManager.prototype._handleNewSuite = function () {
|
|
var allegedSuite = this.containerTestFrame.suite();
|
|
if (allegedSuite.isjsUnitTestSuite) {
|
|
var newSuite = allegedSuite.clone();
|
|
if (newSuite.containsTestPages())
|
|
push(this._suiteStack, newSuite);
|
|
this._nextPage();
|
|
}
|
|
else {
|
|
this.fatalError('Invalid test suite in file ' + this._testFileName);
|
|
this.abort();
|
|
}
|
|
}
|
|
|
|
jsUnitTestManager.prototype._runTest = function () {
|
|
if (this._testIndex + 1 > this._numberOfTestsInPage)
|
|
{
|
|
// execute tearDownPage *synchronously*
|
|
// (unlike setUpPage which is asynchronous)
|
|
if (typeof this.containerTestFrame.tearDownPage == 'function') {
|
|
this.containerTestFrame.tearDownPage();
|
|
}
|
|
|
|
this._nextPage();
|
|
return;
|
|
}
|
|
|
|
if (this._testIndex == 0) {
|
|
this.storeRestoredHTML();
|
|
if (typeof(this.containerTestFrame.setUpPage) == 'function') {
|
|
// first test for this page and a setUpPage is defined
|
|
if (typeof(this.containerTestFrame.setUpPageStatus) == 'undefined') {
|
|
// setUpPage() not called yet, so call it
|
|
this.containerTestFrame.setUpPageStatus = false;
|
|
this.containerTestFrame.startTime = new Date();
|
|
this.containerTestFrame.setUpPage();
|
|
// try test again later
|
|
setTimeout('top.testManager._runTest()', jsUnitTestManager.SETUPPAGE_INTERVAL);
|
|
return;
|
|
}
|
|
|
|
if (this.containerTestFrame.setUpPageStatus != 'complete') {
|
|
top.status = 'setUpPage not completed... ' + this.containerTestFrame.setUpPageStatus + ' ' + (new Date());
|
|
if ((new Date() - this.containerTestFrame.startTime) / 1000 > this.getsetUpPageTimeout()) {
|
|
this.fatalError('setUpPage timed out without completing.');
|
|
if (!this.userConfirm('Retry Test Run?')) {
|
|
this.abort();
|
|
return;
|
|
}
|
|
this.containerTestFrame.startTime = (new Date());
|
|
}
|
|
// try test again later
|
|
setTimeout('top.testManager._runTest()', jsUnitTestManager.SETUPPAGE_INTERVAL);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
top.status = '';
|
|
// either not first test, or no setUpPage defined, or setUpPage completed
|
|
this.executeTestFunction(this._testsInPage[this._testIndex]);
|
|
this.totalCount++;
|
|
this.updateProgressIndicators();
|
|
this._testIndex++;
|
|
setTimeout('top.testManager._runTest()', jsUnitTestManager.TIMEOUT_LENGTH);
|
|
}
|
|
|
|
jsUnitTestManager.prototype._done = function () {
|
|
var secondsSinceRunBegan = (new Date() - this._timeRunStarted) / 1000;
|
|
this.setStatus('Done (' + secondsSinceRunBegan + ' seconds)');
|
|
this._cleanUp();
|
|
if (top.shouldSubmitResults()) {
|
|
this.resultsTimeField.value = secondsSinceRunBegan;
|
|
top.submitResults();
|
|
}
|
|
}
|
|
|
|
jsUnitTestManager.prototype._nextPage = function () {
|
|
this._restoredHTML = null;
|
|
if (this._currentSuite().hasMorePages()) {
|
|
this.loadPage(this._currentSuite().nextPage());
|
|
}
|
|
else {
|
|
pop(this._suiteStack);
|
|
if (this._currentSuite() == null)
|
|
this._done();
|
|
else
|
|
this._nextPage();
|
|
}
|
|
}
|
|
|
|
jsUnitTestManager.prototype._currentSuite = function () {
|
|
var suite = null;
|
|
|
|
if (this._suiteStack && this._suiteStack.length > 0)
|
|
suite = this._suiteStack[this._suiteStack.length - 1];
|
|
|
|
return suite;
|
|
}
|
|
|
|
jsUnitTestManager.prototype.calculateProgressBarProportion = function () {
|
|
if (this.totalCount == 0)
|
|
return 0;
|
|
var currentDivisor = 1;
|
|
var result = 0;
|
|
|
|
for (var i = 0; i < this._suiteStack.length; i++) {
|
|
var aSuite = this._suiteStack[i];
|
|
currentDivisor *= aSuite.testPages.length;
|
|
result += (aSuite.pageIndex - 1) / currentDivisor;
|
|
}
|
|
result += (this._testIndex + 1) / (this._numberOfTestsInPage * currentDivisor);
|
|
return result;
|
|
}
|
|
|
|
jsUnitTestManager.prototype._cleanUp = function () {
|
|
this.containerController.setTestPage('./app/emptyPage.html');
|
|
this.finalize();
|
|
top.tracer.finalize();
|
|
}
|
|
|
|
jsUnitTestManager.prototype.abort = function () {
|
|
this.setStatus('Aborted');
|
|
this._cleanUp();
|
|
}
|
|
|
|
jsUnitTestManager.prototype.getTimeout = function () {
|
|
var result = jsUnitTestManager.TESTPAGE_WAIT_SEC;
|
|
try {
|
|
result = eval(this.timeout.value);
|
|
}
|
|
catch (e) {
|
|
}
|
|
return result;
|
|
}
|
|
|
|
jsUnitTestManager.prototype.getsetUpPageTimeout = function () {
|
|
var result = jsUnitTestManager.SETUPPAGE_TIMEOUT;
|
|
try {
|
|
result = eval(this.setUpPageTimeout.value);
|
|
}
|
|
catch (e) {
|
|
}
|
|
return result;
|
|
}
|
|
|
|
jsUnitTestManager.prototype.isTestPageSuite = function () {
|
|
var result = false;
|
|
if (typeof(this.containerTestFrame.suite) == 'function')
|
|
{
|
|
result = true;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
jsUnitTestManager.prototype.getTestFunctionNames = function () {
|
|
var testFrame = this.containerTestFrame;
|
|
var testFunctionNames = new Array();
|
|
var i;
|
|
|
|
if (testFrame && typeof(testFrame.exposeTestFunctionNames) == 'function')
|
|
return testFrame.exposeTestFunctionNames();
|
|
|
|
if (testFrame &&
|
|
testFrame.document &&
|
|
typeof(testFrame.document.scripts) != 'undefined' &&
|
|
testFrame.document.scripts.length > 0) { // IE5 and up
|
|
var scriptsInTestFrame = testFrame.document.scripts;
|
|
|
|
for (i = 0; i < scriptsInTestFrame.length; i++) {
|
|
var someNames = this._extractTestFunctionNamesFromScript(scriptsInTestFrame[i]);
|
|
if (someNames)
|
|
testFunctionNames = testFunctionNames.concat(someNames);
|
|
}
|
|
}
|
|
else {
|
|
for (i in testFrame) {
|
|
if (i.substring(0, 4) == 'test' && typeof(testFrame[i]) == 'function')
|
|
push(testFunctionNames, i);
|
|
}
|
|
}
|
|
return testFunctionNames;
|
|
}
|
|
|
|
jsUnitTestManager.prototype._extractTestFunctionNamesFromScript = function (aScript) {
|
|
var result;
|
|
var remainingScriptToInspect = aScript.text;
|
|
var currentIndex = this._indexOfTestFunctionIn(remainingScriptToInspect);
|
|
while (currentIndex != -1) {
|
|
if (!result)
|
|
result = new Array();
|
|
|
|
var fragment = remainingScriptToInspect.substring(currentIndex, remainingScriptToInspect.length);
|
|
result = result.concat(fragment.substring('function '.length, fragment.indexOf('(')));
|
|
remainingScriptToInspect = remainingScriptToInspect.substring(currentIndex + 12, remainingScriptToInspect.length);
|
|
currentIndex = this._indexOfTestFunctionIn(remainingScriptToInspect);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
jsUnitTestManager.prototype._indexOfTestFunctionIn = function (string) {
|
|
return string.indexOf('function test');
|
|
}
|
|
|
|
jsUnitTestManager.prototype.loadPage = function (testFileName) {
|
|
this._testFileName = testFileName;
|
|
this._loadAttemptStartTime = new Date();
|
|
this.setStatus('Opening Test Page "' + this._testFileName + '"');
|
|
this.containerController.setTestPage(this._testFileName);
|
|
this._callBackWhenPageIsLoaded();
|
|
}
|
|
|
|
jsUnitTestManager.prototype._callBackWhenPageIsLoaded = function () {
|
|
if ((new Date() - this._loadAttemptStartTime) / 1000 > this.getTimeout()) {
|
|
this.fatalError('Reading Test Page ' + this._testFileName + ' timed out.\nMake sure that the file exists and is a Test Page.');
|
|
if (this.userConfirm('Retry Test Run?')) {
|
|
this.loadPage(this._testFileName);
|
|
return;
|
|
} else {
|
|
this.abort();
|
|
return;
|
|
}
|
|
}
|
|
if (!this._isTestFrameLoaded()) {
|
|
setTimeout('top.testManager._callBackWhenPageIsLoaded();', jsUnitTestManager.TIMEOUT_LENGTH);
|
|
return;
|
|
}
|
|
this.doneLoadingPage(this._testFileName);
|
|
}
|
|
|
|
jsUnitTestManager.prototype._isTestFrameLoaded = function () {
|
|
try {
|
|
return this.containerController.isPageLoaded();
|
|
}
|
|
catch (e) {
|
|
}
|
|
return false;
|
|
}
|
|
|
|
jsUnitTestManager.prototype.executeTestFunction = function (functionName) {
|
|
this._testFunctionName = functionName;
|
|
this.setStatus('Running test "' + this._testFunctionName + '"');
|
|
var excep = null;
|
|
var timeBefore = new Date();
|
|
try {
|
|
if (this._restoredHTML)
|
|
top.testContainer.testFrame.document.getElementById(jsUnitTestManager.RESTORED_HTML_DIV_ID).innerHTML = this._restoredHTML;
|
|
if (this.containerTestFrame.setUp !== JSUNIT_UNDEFINED_VALUE)
|
|
this.containerTestFrame.setUp();
|
|
this.containerTestFrame[this._testFunctionName]();
|
|
}
|
|
catch (e1) {
|
|
excep = e1;
|
|
}
|
|
finally {
|
|
try {
|
|
if (this.containerTestFrame.tearDown !== JSUNIT_UNDEFINED_VALUE)
|
|
this.containerTestFrame.tearDown();
|
|
}
|
|
catch (e2) {
|
|
//Unlike JUnit, only assign a tearDown exception to excep if there is not already an exception from the test body
|
|
if (excep == null)
|
|
excep = e2;
|
|
}
|
|
}
|
|
var timeTaken = (new Date() - timeBefore) / 1000;
|
|
if (excep != null)
|
|
this._handleTestException(excep);
|
|
var serializedTestCaseString = this._currentTestFunctionNameWithTestPageName(true) + "|" + timeTaken + "|";
|
|
if (excep == null)
|
|
serializedTestCaseString += "S||";
|
|
else {
|
|
if (typeof(excep.isJsUnitException) != 'undefined' && excep.isJsUnitException)
|
|
serializedTestCaseString += "F|";
|
|
else {
|
|
serializedTestCaseString += "E|";
|
|
}
|
|
serializedTestCaseString += this._problemDetailMessageFor(excep);
|
|
}
|
|
this._addOption(this.testCaseResultsField,
|
|
serializedTestCaseString,
|
|
serializedTestCaseString);
|
|
}
|
|
|
|
jsUnitTestManager.prototype._currentTestFunctionNameWithTestPageName = function(useFullyQualifiedTestPageName) {
|
|
var testURL = this.containerTestFrame.location.href;
|
|
var testQuery = testURL.indexOf("?");
|
|
if (testQuery >= 0) {
|
|
testURL = testURL.substring(0, testQuery);
|
|
}
|
|
if (!useFullyQualifiedTestPageName) {
|
|
if (testURL.substring(0, this._baseURL.length) == this._baseURL)
|
|
testURL = testURL.substring(this._baseURL.length);
|
|
}
|
|
return testURL + ':' + this._testFunctionName;
|
|
}
|
|
|
|
jsUnitTestManager.prototype._addOption = function(listField, problemValue, problemMessage) {
|
|
if (typeof(listField.ownerDocument) != 'undefined'
|
|
&& typeof(listField.ownerDocument.createElement) != 'undefined') {
|
|
// DOM Level 2 HTML method.
|
|
// this is required for Opera 7 since appending to the end of the
|
|
// options array does not work, and adding an Option created by new Option()
|
|
// and appended by listField.options.add() fails due to WRONG_DOCUMENT_ERR
|
|
var problemDocument = listField.ownerDocument;
|
|
var errOption = problemDocument.createElement('option');
|
|
errOption.setAttribute('value', problemValue);
|
|
errOption.appendChild(problemDocument.createTextNode(problemMessage));
|
|
listField.appendChild(errOption);
|
|
}
|
|
else {
|
|
// new Option() is DOM 0
|
|
errOption = new Option(problemMessage, problemValue);
|
|
if (typeof(listField.add) != 'undefined') {
|
|
// DOM 2 HTML
|
|
listField.add(errOption, null);
|
|
}
|
|
else if (typeof(listField.options.add) != 'undefined') {
|
|
// DOM 0
|
|
listField.options.add(errOption, null);
|
|
}
|
|
else {
|
|
// DOM 0
|
|
listField.options[listField.length] = errOption;
|
|
}
|
|
}
|
|
}
|
|
|
|
jsUnitTestManager.prototype._handleTestException = function (excep) {
|
|
var problemMessage = this._currentTestFunctionNameWithTestPageName(false) + ' ';
|
|
var errOption;
|
|
if (typeof(excep.isJsUnitException) == 'undefined' || !excep.isJsUnitException) {
|
|
problemMessage += 'had an error';
|
|
this.errorCount++;
|
|
}
|
|
else {
|
|
problemMessage += 'failed';
|
|
this.failureCount++;
|
|
}
|
|
var listField = this.problemsListField;
|
|
this._addOption(listField,
|
|
this._problemDetailMessageFor(excep),
|
|
problemMessage);
|
|
}
|
|
|
|
jsUnitTestManager.prototype._problemDetailMessageFor = function (excep) {
|
|
var result = null;
|
|
if (typeof(excep.isJsUnitException) != 'undefined' && excep.isJsUnitException) {
|
|
result = '';
|
|
if (excep.comment != null)
|
|
result += ('"' + excep.comment + '"\n');
|
|
|
|
result += excep.jsUnitMessage;
|
|
|
|
if (excep.stackTrace)
|
|
result += '\n\nStack trace follows:\n' + excep.stackTrace;
|
|
}
|
|
else {
|
|
result = 'Error message is:\n"';
|
|
result +=
|
|
(typeof(excep.description) == 'undefined') ?
|
|
excep :
|
|
excep.description;
|
|
result += '"';
|
|
if (typeof(excep.stack) != 'undefined') // Mozilla only
|
|
result += '\n\nStack trace follows:\n' + excep.stack;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
jsUnitTestManager.prototype._setTextOnLayer = function (layerName, str) {
|
|
try {
|
|
var content;
|
|
if (content = this.uiFrames[layerName].document.getElementById('content'))
|
|
content.innerHTML = str;
|
|
else
|
|
throw 'No content div found.';
|
|
}
|
|
catch (e) {
|
|
var html = '';
|
|
html += '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">';
|
|
html += '<html><head><link rel="stylesheet" type="text/css" href="css/jsUnitStyle.css"><\/head>';
|
|
html += '<body><div id="content">';
|
|
html += str;
|
|
html += '<\/div><\/body>';
|
|
html += '<\/html>';
|
|
this.uiFrames[layerName].document.write(html);
|
|
this.uiFrames[layerName].document.close();
|
|
}
|
|
}
|
|
|
|
jsUnitTestManager.prototype.setStatus = function (str) {
|
|
this._setTextOnLayer('mainStatus', '<b>Status:<\/b> ' + str);
|
|
}
|
|
|
|
jsUnitTestManager.prototype._setErrors = function (n) {
|
|
this._setTextOnLayer('mainCountsErrors', '<b>Errors: <\/b>' + n);
|
|
}
|
|
|
|
jsUnitTestManager.prototype._setFailures = function (n) {
|
|
this._setTextOnLayer('mainCountsFailures', '<b>Failures:<\/b> ' + n);
|
|
}
|
|
|
|
jsUnitTestManager.prototype._setTotal = function (n) {
|
|
this._setTextOnLayer('mainCountsRuns', '<b>Runs:<\/b> ' + n);
|
|
}
|
|
|
|
jsUnitTestManager.prototype._setProgressBarImage = function (imgName) {
|
|
this.progressBar.src = imgName;
|
|
}
|
|
|
|
jsUnitTestManager.prototype._setProgressBarWidth = function (w) {
|
|
this.progressBar.width = w;
|
|
}
|
|
|
|
jsUnitTestManager.prototype.updateProgressIndicators = function () {
|
|
this._setTotal(this.totalCount);
|
|
this._setErrors(this.errorCount);
|
|
this._setFailures(this.failureCount);
|
|
this._setProgressBarWidth(300 * this.calculateProgressBarProportion());
|
|
|
|
if (this.errorCount > 0 || this.failureCount > 0)
|
|
this._setProgressBarImage('../images/red.gif');
|
|
else
|
|
this._setProgressBarImage('../images/green.gif');
|
|
}
|
|
|
|
jsUnitTestManager.prototype.showMessageForSelectedProblemTest = function () {
|
|
var problemTestIndex = this.problemsListField.selectedIndex;
|
|
if (problemTestIndex != -1)
|
|
this.fatalError(this.problemsListField[problemTestIndex].value);
|
|
}
|
|
|
|
jsUnitTestManager.prototype.showMessagesForAllProblemTests = function () {
|
|
if (this.problemsListField.length == 0)
|
|
return;
|
|
|
|
try {
|
|
if (this._windowForAllProblemMessages && !this._windowForAllProblemMessages.closed)
|
|
this._windowForAllProblemMessages.close();
|
|
}
|
|
catch(e) {
|
|
}
|
|
|
|
this._windowForAllProblemMessages = window.open('', '', 'width=600, height=350,status=no,resizable=yes,scrollbars=yes');
|
|
var resDoc = this._windowForAllProblemMessages.document;
|
|
resDoc.write('<html><head><link rel="stylesheet" href="../css/jsUnitStyle.css"><title>Tests with problems - JsUnit<\/title><head><body>');
|
|
resDoc.write('<p class="jsUnitSubHeading">Tests with problems (' + this.problemsListField.length + ' total) - JsUnit<\/p>');
|
|
resDoc.write('<p class="jsUnitSubSubHeading"><i>Running on ' + navigator.userAgent + '</i></p>');
|
|
for (var i = 0; i < this.problemsListField.length; i++)
|
|
{
|
|
resDoc.write('<p class="jsUnitDefault">');
|
|
resDoc.write('<b>' + (i + 1) + '. ');
|
|
resDoc.write(this.problemsListField[i].text);
|
|
resDoc.write('<\/b><\/p><p><pre>');
|
|
resDoc.write(this._makeHTMLSafe(this.problemsListField[i].value));
|
|
resDoc.write('<\/pre><\/p>');
|
|
}
|
|
|
|
resDoc.write('<\/body><\/html>');
|
|
resDoc.close();
|
|
}
|
|
|
|
jsUnitTestManager.prototype._makeHTMLSafe = function (string) {
|
|
string = string.replace(/&/g, '&');
|
|
string = string.replace(/</g, '<');
|
|
string = string.replace(/>/g, '>');
|
|
return string;
|
|
}
|
|
|
|
jsUnitTestManager.prototype._clearProblemsList = function () {
|
|
var listField = this.problemsListField;
|
|
var initialLength = listField.options.length;
|
|
|
|
for (var i = 0; i < initialLength; i++)
|
|
listField.remove(0);
|
|
}
|
|
|
|
jsUnitTestManager.prototype.initialize = function () {
|
|
this.setStatus('Initializing...');
|
|
this._setRunButtonEnabled(false);
|
|
this._clearProblemsList();
|
|
this.updateProgressIndicators();
|
|
this.setStatus('Done initializing');
|
|
}
|
|
|
|
jsUnitTestManager.prototype.finalize = function () {
|
|
this._setRunButtonEnabled(true);
|
|
}
|
|
|
|
jsUnitTestManager.prototype._setRunButtonEnabled = function (b) {
|
|
this.runButton.disabled = !b;
|
|
}
|
|
|
|
jsUnitTestManager.prototype.getTestFileName = function () {
|
|
var rawEnteredFileName = this.testFileName.value;
|
|
var result = rawEnteredFileName;
|
|
|
|
while (result.indexOf('\\') != -1)
|
|
result = result.replace('\\', '/');
|
|
|
|
return result;
|
|
}
|
|
|
|
jsUnitTestManager.prototype.getTestFunctionName = function () {
|
|
return this._testFunctionName;
|
|
}
|
|
|
|
jsUnitTestManager.prototype.resolveUserEnteredTestFileName = function (rawText) {
|
|
var userEnteredTestFileName = top.testManager.getTestFileName();
|
|
|
|
// only test for file:// since Opera uses a different format
|
|
if (userEnteredTestFileName.indexOf('http://') == 0 || userEnteredTestFileName.indexOf('https://') == 0 || userEnteredTestFileName.indexOf('file://') == 0)
|
|
return userEnteredTestFileName;
|
|
|
|
return getTestFileProtocol() + this.getTestFileName();
|
|
}
|
|
|
|
jsUnitTestManager.prototype.storeRestoredHTML = function () {
|
|
if (document.getElementById && top.testContainer.testFrame.document.getElementById(jsUnitTestManager.RESTORED_HTML_DIV_ID))
|
|
this._restoredHTML = top.testContainer.testFrame.document.getElementById(jsUnitTestManager.RESTORED_HTML_DIV_ID).innerHTML;
|
|
}
|
|
|
|
jsUnitTestManager.prototype.fatalError = function(aMessage) {
|
|
if (top.shouldSubmitResults())
|
|
this.setStatus(aMessage);
|
|
else
|
|
alert(aMessage);
|
|
}
|
|
|
|
jsUnitTestManager.prototype.userConfirm = function(aMessage) {
|
|
if (top.shouldSubmitResults())
|
|
return false;
|
|
else
|
|
return confirm(aMessage);
|
|
}
|
|
|
|
function getTestFileProtocol() {
|
|
return getDocumentProtocol();
|
|
}
|
|
|
|
function getDocumentProtocol() {
|
|
var protocol = top.document.location.protocol;
|
|
|
|
if (protocol == "file:")
|
|
return "file:///";
|
|
|
|
if (protocol == "http:")
|
|
return "http://";
|
|
|
|
if (protocol == 'https:')
|
|
return 'https://';
|
|
|
|
if (protocol == "chrome:")
|
|
return "chrome://";
|
|
|
|
return null;
|
|
}
|
|
|
|
function browserSupportsReadingFullPathFromFileField() {
|
|
return !isOpera() && !isIE7();
|
|
}
|
|
|
|
function isOpera() {
|
|
return navigator.userAgent.toLowerCase().indexOf("opera") != -1;
|
|
}
|
|
|
|
function isIE7() {
|
|
return navigator.userAgent.toLowerCase().indexOf("msie 7") != -1;
|
|
}
|
|
|
|
function isBeingRunOverHTTP() {
|
|
return getDocumentProtocol() == "http://";
|
|
}
|
|
|
|
function getWebserver() {
|
|
if (isBeingRunOverHTTP()) {
|
|
var myUrl = location.href;
|
|
var myUrlWithProtocolStripped = myUrl.substring(myUrl.indexOf("/") + 2);
|
|
return myUrlWithProtocolStripped.substring(0, myUrlWithProtocolStripped.indexOf("/"));
|
|
}
|
|
return null;
|
|
}
|
|
|
|
// the functions push(anArray, anObject) and pop(anArray)
|
|
// exist because the JavaScript Array.push(anObject) and Array.pop()
|
|
// functions are not available in IE 5.0
|
|
|
|
function push(anArray, anObject) {
|
|
anArray[anArray.length] = anObject;
|
|
}
|
|
|
|
function pop(anArray) {
|
|
if (anArray.length >= 1) {
|
|
delete anArray[anArray.length - 1];
|
|
anArray.length--;
|
|
}
|
|
}
|
|
|
|
if (xbDEBUG.on) {
|
|
xbDebugTraceObject('window', 'jsUnitTestManager');
|
|
xbDebugTraceFunction('window', 'getTestFileProtocol');
|
|
xbDebugTraceFunction('window', 'getDocumentProtocol');
|
|
}
|