selenium-webdriver 0.0.9 → 0.0.10

data/common/src/js/jsunit/app/jsUnitMockTimeout.js

@@ -0,0 +1,81 @@
+// Mock setTimeout, clearTimeout
+// Contributed by Pivotal Computer Systems, www.pivotalsf.com
+
+var Clock = {
+    timeoutsMade: 0,
+    scheduledFunctions: {},
+    nowMillis: 0,
+    reset: function() {
+        this.scheduledFunctions = {};
+        this.nowMillis = 0;
+        this.timeoutsMade = 0;
+    },
+    tick: function(millis) {
+        var oldMillis = this.nowMillis;
+        var newMillis = oldMillis + millis;
+        this.runFunctionsWithinRange(oldMillis, newMillis);
+        this.nowMillis = newMillis;
+    },
+    runFunctionsWithinRange: function(oldMillis, nowMillis) {
+        var scheduledFunc;
+        var funcsToRun = [];
+        for (var timeoutKey in this.scheduledFunctions) {
+            scheduledFunc = this.scheduledFunctions[timeoutKey];
+            if (scheduledFunc != undefined &&
+                scheduledFunc.runAtMillis >= oldMillis &&
+                scheduledFunc.runAtMillis <= nowMillis) {
+                funcsToRun.push(scheduledFunc);
+                this.scheduledFunctions[timeoutKey] = undefined;
+            }
+        }
+
+        if (funcsToRun.length > 0) {
+            funcsToRun.sort(function(a, b) {
+                return a.runAtMillis - b.runAtMillis;
+            });
+            for (var i = 0; i < funcsToRun.length; ++i) {
+                try {
+                    this.nowMillis = funcsToRun[i].runAtMillis;
+                    funcsToRun[i].funcToCall();
+                    if (funcsToRun[i].recurring) {
+                        Clock.scheduleFunction(funcsToRun[i].timeoutKey,
+                                funcsToRun[i].funcToCall,
+                                funcsToRun[i].millis,
+                                true);
+                    }
+                } catch(e) {
+                }
+            }
+            this.runFunctionsWithinRange(oldMillis, nowMillis);
+        }
+    },
+    scheduleFunction: function(timeoutKey, funcToCall, millis, recurring) {
+        Clock.scheduledFunctions[timeoutKey] = {
+            runAtMillis: Clock.nowMillis + millis,
+            funcToCall: funcToCall,
+            recurring: recurring,
+            timeoutKey: timeoutKey,
+            millis: millis
+        };
+    }
+};
+
+function setTimeout(funcToCall, millis) {
+    Clock.timeoutsMade = Clock.timeoutsMade + 1;
+    Clock.scheduleFunction(Clock.timeoutsMade, funcToCall, millis, false);
+    return Clock.timeoutsMade;
+}
+
+function setInterval(funcToCall, millis) {
+    Clock.timeoutsMade = Clock.timeoutsMade + 1;
+    Clock.scheduleFunction(Clock.timeoutsMade, funcToCall, millis, true);
+    return Clock.timeoutsMade;
+}
+
+function clearTimeout(timeoutKey) {
+    Clock.scheduledFunctions[timeoutKey] = undefined;
+}
+
+function clearInterval(timeoutKey) {
+    Clock.scheduledFunctions[timeoutKey] = undefined;
+}

data/common/src/js/jsunit/app/jsUnitTestManager.js

@@ -0,0 +1,705 @@
+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, '&amp;');
+    string = string.replace(/</g, '&lt;');
+    string = string.replace(/>/g, '&gt;');
+    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');
+}