rubinium 0.1.1

data/vendor/selenium-0.6.0/selenium/selenium-executionloop.js

@@ -0,0 +1,250 @@
+/*
+* Copyright 2004 ThoughtWorks, Inc
+*
+*  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.
+*/
+
+SELENIUM_PROCESS_WAIT = "wait";
+
+starting_up  = true;
+TEST_FINISHED = true;
+TEST_CONTINUE = false;
+
+function TestLoop(commandFactory) {
+    this.commandFactory = commandFactory;
+
+    this.start = function() {
+        selenium.reset();
+        this.continueCurrentTest();
+    };
+
+    this.continueCurrentTest = function() {
+        var testStatus = this.kickoffNextCommandExecution();
+
+        if (testStatus == TEST_FINISHED) {
+            this.testComplete();
+        }
+    };
+
+    this.kickoffNextCommandExecution = function() {
+
+        var command;
+        if (starting_up == true) {
+            command = this.firstCommand();
+            starting_up = false;
+        } else {
+            command = this.nextCommand();
+        }
+
+        if (!command) return TEST_FINISHED;
+
+        this.commandStarted(command);
+
+        LOG.info("Executing: |" + command.command + " | " + command.target + " | " + command.value + " |");
+
+        var result;
+        try {
+            var handler = this.commandFactory.getCommandHandler(command.command);
+            if(handler == null) {
+                throw new Error("Unknown command: '" + command.command + "'");
+            }
+
+            command.target = selenium.preprocessParameter(command.target);
+            command.value = selenium.preprocessParameter(command.value);
+
+            result = handler.execute(selenium, command);
+        } catch (e) {
+            this.handleCommandError(e);
+            return TEST_FINISHED;
+        }
+
+        // Record the result so that we can continue the execution using
+        // window.setTimeout()
+        this.lastCommandResult = result;
+        if (result.processState == SELENIUM_PROCESS_WAIT) {
+            this.waitForCondition = function() {
+                return selenium.browserbot.isNewPageLoaded();
+            };
+        }
+
+        if (this.waitForCondition) {
+            this.pollUntilConditionIsTrue();
+        } else {
+            // Continue processing
+            this.continueCommandExecutionWithDelay();
+        }
+
+        // Test is not finished.
+        return TEST_CONTINUE;
+    };
+
+    this.handleCommandError = function(e) {
+       if (!e.isSeleniumError) {
+            LOG.exception(e);
+            var msg = "Selenium failure. Please report to selenium-devel@lists.public.thoughtworks.org, with details from the logs at the base of the page.";
+            if (e.message) {
+               msg += "  The error message is: " + e.message;
+            }
+            this.commandError(msg);
+        } else {
+            LOG.error(e.message);
+            this.commandError(e.message);
+        }
+    };
+
+    /**
+     * Busy wait for waitForCondition() to become true, and then continue
+     * command execution.
+     */
+    this.pollUntilConditionIsTrue = function () {
+        if (this.waitForCondition()) {
+            this.waitForCondition = null;
+            this.continueCommandExecutionWithDelay();
+        } else {
+            window.setTimeout("testLoop.pollUntilConditionIsTrue()", 10);
+        }
+    };
+
+
+    /**
+     * Continue the command execution, after waiting for the specified
+     * delay.
+     */
+    this.continueCommandExecutionWithDelay = function() {
+        // Get the interval to use for this command execution, using the pauseInterval as
+        // specified. Reset the pause interval, since it's a one-off thing.
+        var interval = this.pauseInterval || this.getCommandInterval();
+        this.pauseInterval = undefined;
+
+        if (interval < 0) {
+            // Enable the "next/continue" button
+            this.pause();
+        }
+        else {
+            // Continue processing
+            window.setTimeout("testLoop.finishCommandExecution()", interval);
+        }
+    };
+
+    /**
+     * Finish the execution of the previous command, and continue the test.
+     */
+    this.finishCommandExecution = function() {
+        this.commandComplete(this.lastCommandResult);
+        this.continueCurrentTest();
+    };
+}
+
+/** The default is not to have any interval between commands. */
+TestLoop.prototype.getCommandInterval = function() {
+    return 0;
+};
+
+TestLoop.prototype.firstCommand = noop;
+
+TestLoop.prototype.nextCommand = noop;
+
+TestLoop.prototype.commandStarted = noop;
+
+TestLoop.prototype.commandError = noop;
+
+TestLoop.prototype.commandComplete = noop;
+
+TestLoop.prototype.testComplete = noop;
+
+TestLoop.prototype.pause = noop;
+
+function noop() {
+
+};
+
+/**
+ * Tell Selenium to expect a failure on the next command execution. This
+ * command temporarily installs a CommandFactory that generates
+ * CommandHandlers that expect a failure.
+ */
+Selenium.prototype.assertFailureOnNext = function(message) {
+    if (!message) {
+        throw new Error("Message must be provided");
+    }
+
+    var expectFailureCommandFactory =
+        new ExpectFailureCommandFactory(testLoop.commandFactory, message);
+    expectFailureCommandFactory.baseExecutor = executeCommandAndReturnFailureMessage;
+    testLoop.commandFactory = expectFailureCommandFactory;
+};
+
+/**
+ * Tell Selenium to expect an error on the next command execution. This
+ * command temporarily installs a CommandFactory that generates
+ * CommandHandlers that expect a failure.
+ */
+Selenium.prototype.assertErrorOnNext = function(message) {
+    if (!message) {
+        throw new Error("Message must be provided");
+    }
+
+    var expectFailureCommandFactory =
+        new ExpectFailureCommandFactory(testLoop.commandFactory, message);
+    expectFailureCommandFactory.baseExecutor = executeCommandAndReturnErrorMessage;
+    testLoop.commandFactory = expectFailureCommandFactory;
+};
+
+function ExpectFailureCommandFactory(originalCommandFactory, expectedErrorMessage) {
+    this.getCommandHandler = function(name) {
+        var baseHandler = originalCommandFactory.getCommandHandler(name);
+        var baseExecutor = this.baseExecutor;
+        var expectFailureCommand = {};
+        expectFailureCommand.execute = function() {
+            var baseFailureMessage = baseExecutor(baseHandler, arguments);
+            var result = new CommandResult();
+            if (!baseFailureMessage) {
+                result.failed = true;
+                result.failureMessage = "Command should have failed.";
+            }
+            else {
+                if (! PatternMatcher.matches(expectedErrorMessage, baseFailureMessage)) {
+                    result.failed = true;
+                    result.failureMessage = "Expected failure message '" + expectedErrorMessage
+                                            + "' but was '" + baseFailureMessage + "'";
+                }
+                else {
+                    result.passed = true;
+                    result.result = baseFailureMessage;
+                }
+            }
+            testLoop.commandFactory = originalCommandFactory;
+            return result;
+        };
+        return expectFailureCommand;
+    };
+};
+
+function executeCommandAndReturnFailureMessage(baseHandler, originalArguments) {
+    var baseResult = baseHandler.execute.apply(baseHandler, originalArguments);
+    if (baseResult.passed) {
+        return null;
+    }
+    return baseResult.failureMessage;
+};
+
+function executeCommandAndReturnErrorMessage(baseHandler, originalArguments) {
+    try {
+        baseHandler.execute.apply(baseHandler, originalArguments);
+        return null;
+    }
+    catch (expected) {
+        return expected.message;
+    }
+};
+

data/vendor/selenium-0.6.0/selenium/selenium-fitrunner.js

@@ -0,0 +1,597 @@
+/*
+* Copyright 2004 ThoughtWorks, Inc
+*
+*  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.
+*
+*/
+
+passColor = "#cfffcf";
+failColor = "#ffcfcf";
+workingColor = "#DEE7EC";
+
+// The current row in the list of commands (test script)
+currentCommandRow = 0;
+inputTableRows = null;
+
+// The current row in the list of tests (test suite)
+currentTestRow = 0;
+
+// Whether or not the jsFT should run all tests in the suite
+runAllTests = false;
+
+// Whether or not the current test has any errors;
+testFailed = false;
+suiteFailed = false;
+
+// Holds the handlers for each command.
+commandHandlers = null;
+
+// The number of tests run
+numTestPasses = 0;
+
+// The number of tests that have failed
+numTestFailures = 0;
+
+// The number of commands which have passed
+numCommandPasses = 0;
+
+// The number of commands which have failed
+numCommandFailures = 0;
+
+// The number of commands which have caused errors (element not found)
+numCommandErrors = 0;
+
+// The time that the test was started.
+startTime = null;
+
+// The current time.
+currentTime = null;
+
+// An simple enum for failureType
+ERROR = 0;
+FAILURE = 1;
+
+runInterval = 0;
+
+function setRunInterval() {
+    // Get the value of the checked runMode option.
+    // There should be a way of getting the value of the "group", but I don't know how.
+    var runModeOptions = document.forms['controlPanel'].runMode;
+    for (var i = 0; i < runModeOptions.length; i++) {
+        if (runModeOptions[i].checked) {
+            runInterval = runModeOptions[i].value;
+            break;
+        }
+    }
+}
+
+function continueCurrentTest() {
+    document.getElementById('continueTest').disabled = true;
+    testLoop.finishCommandExecution();
+}
+
+function getApplicationFrame() {
+    return document.getElementById('myiframe');
+}
+
+function getSuiteFrame() {
+    return document.getElementById('testSuiteFrame');
+}
+
+function getTestFrame(){
+    return document.getElementById('testFrame');
+}
+
+function loadAndRunIfAuto() {
+    loadSuiteFrame();
+}
+
+function start() {
+    setRunInterval();
+    loadSuiteFrame();
+}
+
+function loadSuiteFrame() {
+    var testAppFrame = document.getElementById('myiframe');
+    selenium = Selenium.createForFrame(testAppFrame);
+    registerCommandHandlers();
+
+    //set the runInterval if there is a queryParameter for it
+    var tempRunInterval = getQueryParameter("runInterval");
+    if (tempRunInterval) {
+        runInterval = tempRunInterval;
+    }
+
+    document.getElementById("modeRun").onclick = setRunInterval;
+    document.getElementById('modeWalk').onclick = setRunInterval;
+    document.getElementById('modeStep').onclick = setRunInterval;
+    document.getElementById('continueTest').onclick = continueCurrentTest;
+
+    var testSuiteName = getQueryParameter("test");
+
+    if (testSuiteName) {
+        addLoadListener(getSuiteFrame(), onloadTestSuite);
+        getSuiteFrame().src = testSuiteName;
+    } else {
+        onloadTestSuite();
+    }
+}
+
+function startSingleTest() {
+    removeLoadListener(getApplicationFrame(), startSingleTest);
+    var singleTestName = getQueryParameter("singletest");
+    addLoadListener(getTestFrame(), startTest);
+    getTestFrame().src = singleTestName;
+}
+
+function getIframeDocument(iframe)
+{
+    if (iframe.contentDocument) {
+        return iframe.contentDocument;
+    }
+    else {
+        return iframe.contentWindow.document;
+    }
+}
+
+function onloadTestSuite() {
+    removeLoadListener(getSuiteFrame(), onloadTestSuite);
+    suiteTable = getIframeDocument(getSuiteFrame()).getElementsByTagName("table")[0];
+
+    // Add an onclick function to each link in the suite table
+    for(rowNum = 1;rowNum < suiteTable.rows.length; rowNum++) {
+        addOnclick(suiteTable, rowNum);
+    }
+
+
+    if (isAutomatedRun()) {
+        startTestSuite();
+    } else if (getQueryParameter("autoURL")) {
+
+        addLoadListener(getApplicationFrame(), startSingleTest);
+
+        getApplicationFrame().src = getQueryParameter("autoURL");
+
+    } else {
+        testLink = suiteTable.rows[currentTestRow+1].cells[0].getElementsByTagName("a")[0];
+        getTestFrame().src = testLink.href;
+    }
+}
+
+// Adds an onclick function to the link in the given row in suite table.
+// This function checks whether the test has already been run and the data is
+// stored. If the data is stored, it sets the test frame to be the stored data.
+// Otherwise, it loads the fresh page.
+function addOnclick(suiteTable, rowNum) {
+    aLink = suiteTable.rows[rowNum].cells[0].getElementsByTagName("a")[0];
+    aLink.onclick = function(eventObj) {
+        srcObj = null;
+
+        // For mozilla-like browsers
+        if(eventObj)
+                srcObj = eventObj.target;
+
+        // For IE-like browsers
+        else if (getSuiteFrame().contentWindow.event)
+                srcObj = getSuiteFrame().contentWindow.event.srcElement;
+
+        // The target row (the event source is not consistently reported by browsers)
+        row = srcObj.parentNode.parentNode.rowIndex || srcObj.parentNode.parentNode.parentNode.rowIndex;
+
+        // If the row has a stored results table, use that
+        if(suiteTable.rows[row].cells[1]) {
+            var bodyElement = getIframeDocument(getTestFrame()).body;
+
+            // Create a div element to hold the results table.
+            var tableNode = getIframeDocument(getTestFrame()).createElement("div");
+            var resultsCell = suiteTable.rows[row].cells[1];
+            tableNode.innerHTML = resultsCell.innerHTML;
+
+            // Append this text node, and remove all the preceding nodes.
+            bodyElement.appendChild(tableNode);
+            while (bodyElement.firstChild != bodyElement.lastChild) {
+                bodyElement.removeChild(bodyElement.firstChild);
+            }
+        }
+        // Otherwise, just open up the fresh page.
+        else {
+            getTestFrame().src = suiteTable.rows[row].cells[0].getElementsByTagName("a")[0].href;
+        }
+
+        return false;
+    };
+}
+
+function isQueryParameterTrue(name) {
+    parameterValue = getQueryParameter(name);
+    return (parameterValue != null && parameterValue.toLowerCase() == "true");
+}
+
+function getQueryParameter(searchKey) {
+    var clauses = location.search.substr(1).split('&');
+    for (var i = 0; i < clauses.length; i++) {
+        var keyValuePair = clauses[i].split('=',2);
+        var key = unescape(keyValuePair[0]);
+        if (key == searchKey) {
+            return unescape(keyValuePair[1]);
+        }
+    }
+    return null;
+}
+
+function isNewWindow() {
+    return isQueryParameterTrue("newWindow");
+}
+
+function isAutomatedRun() {
+    return isQueryParameterTrue("auto");
+}
+
+function resetMetrics() {
+    numTestPasses = 0;
+    numTestFailures = 0;
+    numCommandPasses = 0;
+    numCommandFailures = 0;
+    numCommandErrors = 0;
+    startTime = new Date().getTime();
+}
+
+function runSingleTest() {
+    runAllTests = false;
+    resetMetrics();
+    startTest();
+}
+
+function startTest() {
+    removeLoadListener(getTestFrame(), startTest);
+
+    // Scroll to the top of the test frame
+    if (getTestFrame().contentWindow) {
+        getTestFrame().contentWindow.scrollTo(0,0);
+    }
+    else {
+        frames['testFrame'].scrollTo(0,0);
+    }
+
+    inputTable = getIframeDocument(getTestFrame()).getElementsByTagName("table")[0];
+    inputTableRows = inputTable.rows;
+    currentCommandRow = 0;
+    testFailed = false;
+    storedVars = new Object();
+
+    clearRowColours();
+
+    testLoop = initialiseTestLoop();
+    testLoop.start();
+}
+
+function clearRowColours() {
+    for (var i = 0; i <= inputTableRows.length - 1; i++) {
+        inputTableRows[i].bgColor = "white";
+    }
+}
+
+function startTestSuite() {
+    resetMetrics();
+    currentTestRow = 0;
+    runAllTests = true;
+    suiteFailed = false;
+
+    runNextTest();
+}
+
+function runNextTest() {
+    if (!runAllTests)
+            return;
+
+    suiteTable = getIframeDocument(getSuiteFrame()).getElementsByTagName("table")[0];
+
+    // Do not change the row color of the first row
+    if(currentTestRow > 0) {
+        // Make the previous row green or red depending if the test passed or failed
+        if(testFailed)
+                setCellColor(suiteTable.rows, currentTestRow, 0, failColor);
+        else
+                setCellColor(suiteTable.rows, currentTestRow, 0, passColor);
+
+        // Set the results from the previous test run
+        setResultsData(suiteTable, currentTestRow);
+    }
+
+    currentTestRow++;
+
+    // If we are done with all of the tests, set the title bar as pass or fail
+    if(currentTestRow >= suiteTable.rows.length) {
+        if(suiteFailed)
+                setCellColor(suiteTable.rows, 0, 0, failColor);
+        else
+                setCellColor(suiteTable.rows, 0, 0, passColor);
+
+        // If this is an automated run (i.e., build script), then submit
+        // the test results by posting to a form
+        if (isAutomatedRun())
+                postTestResults(suiteFailed, suiteTable);
+    }
+
+    else {
+        // Make the current row blue
+        setCellColor(suiteTable.rows, currentTestRow, 0, workingColor);
+
+        testLink = suiteTable.rows[currentTestRow].cells[0].getElementsByTagName("a")[0];
+        testLink.focus();
+
+        var testFrame = getTestFrame();
+        addLoadListener(testFrame, startTest);
+
+        selenium.browserbot.setIFrameLocation(testFrame, testLink.href);
+    }
+}
+
+function setCellColor(tableRows, row, col, colorStr) {
+    tableRows[row].cells[col].bgColor = colorStr;
+}
+
+// Sets the results from a test into a hidden column on the suite table.  So,
+// for each tests, the second column is set to the HTML from the test table.
+function setResultsData(suiteTable, row) {
+    // Create a text node of the test table
+    var resultTable = getIframeDocument(getTestFrame()).body.innerHTML;
+    if (!resultTable) return;
+
+    var tableNode = suiteTable.ownerDocument.createElement("div");
+    tableNode.innerHTML = resultTable;
+
+    var new_column = suiteTable.ownerDocument.createElement("td");
+    new_column.appendChild(tableNode);
+
+    // Set the column to be invisible
+    new_column.style.cssText = "display: none;";
+
+    // Add the invisible column
+    suiteTable.rows[row].appendChild(new_column);
+}
+
+// Post the results to a servlet, CGI-script, etc.  The URL of the
+// results-handler defaults to "/postResults", but an alternative location
+// can be specified by providing a "resultsUrl" query parameter.
+//
+// Parameters passed to the results-handler are:
+//      result:         passed/failed depending on whether the suite passed or failed
+//      totalTime:      the total running time in seconds for the suite.
+//
+//      numTestPasses:  the total number of tests which passed.
+//      numTestFailures: the total number of tests which failed.
+//
+//      numCommandPasses: the total number of commands which passed.
+//      numCommandFailures: the total number of commands which failed.
+//      numCommandErrors: the total number of commands which errored.
+//
+//      suite:      the suite table, including the hidden column of test results
+//      testTable.1 to testTable.N: the individual test tables
+//
+function postTestResults(suiteFailed, suiteTable) {
+
+    form = document.createElement("form");
+    document.body.appendChild(form);
+
+    form.id = "resultsForm";
+    form.method="post";
+    form.target="myiframe";
+
+    var resultsUrl = getQueryParameter("resultsUrl");
+    if (!resultsUrl) {
+        resultsUrl = "./postResults";
+    }
+
+    var actionAndParameters = resultsUrl.split('?',2);
+    form.action = actionAndParameters[0];
+    var resultsUrlQueryString = actionAndParameters[1];
+
+    form.createHiddenField = function(name, value) {
+        input = document.createElement("input");
+        input.type = "hidden";
+        input.name = name;
+        input.value = value;
+        this.appendChild(input);
+    };
+
+    if (resultsUrlQueryString) {
+        var clauses = resultsUrlQueryString.split('&');
+        for (var i = 0; i < clauses.length; i++) {
+            var keyValuePair = clauses[i].split('=',2);
+            var key = unescape(keyValuePair[0]);
+            var value = unescape(keyValuePair[1]);
+            form.createHiddenField(key, value);
+        }
+    }
+
+    form.createHiddenField("result", suiteFailed == true ? "failed" : "passed");
+
+    form.createHiddenField("totalTime", Math.floor((currentTime - startTime) / 1000));
+    form.createHiddenField("numTestPasses", numTestPasses);
+    form.createHiddenField("numTestFailures", numTestFailures);
+    form.createHiddenField("numCommandPasses", numCommandPasses);
+    form.createHiddenField("numCommandFailures", numCommandFailures);
+    form.createHiddenField("numCommandErrors", numCommandErrors);
+
+    // Create an input for each test table.  The inputs are named
+    // testTable.1, testTable.2, etc.
+    for (rowNum = 1; rowNum < suiteTable.rows.length;rowNum++) {
+        // If there is a second column, then add a new input
+        if (suiteTable.rows[rowNum].cells.length > 1) {
+            var resultCell = suiteTable.rows[rowNum].cells[1];
+            form.createHiddenField("testTable." + rowNum, resultCell.innerHTML);
+            // remove the resultCell, so it's not included in the suite HTML
+            resultCell.parentNode.removeChild(resultCell); 
+        }
+    }
+
+    // Add HTML for the suite itself
+    form.createHiddenField("suite", suiteTable.parentNode.innerHTML);
+
+    form.submit();
+    document.body.removeChild(form);
+
+}
+
+function printMetrics() {
+    setText(document.getElementById("commandPasses"), numCommandPasses);
+    setText(document.getElementById("commandFailures"), numCommandFailures);
+    setText(document.getElementById("commandErrors"), numCommandErrors);
+    setText(document.getElementById("testRuns"), numTestPasses + numTestFailures);
+    setText(document.getElementById("testFailures"), numTestFailures);
+
+    currentTime = new Date().getTime();
+
+    timeDiff = currentTime - startTime;
+    totalSecs = Math.floor(timeDiff / 1000);
+
+    minutes = Math.floor(totalSecs / 60);
+    seconds = totalSecs % 60;
+
+    setText(document.getElementById("elapsedTime"), pad(minutes)+":"+pad(seconds));
+}
+
+// Puts a leading 0 on num if it is less than 10
+function pad (num) {
+    return (num > 9) ? num : "0" + num;
+}
+
+/*
+ * Register all of the built-in command handlers with the CommandHandlerFactory.
+ * TODO work out an easy way for people to register handlers without modifying the Selenium sources.
+ */
+function registerCommandHandlers() {
+    commandFactory = new CommandHandlerFactory();
+    commandFactory.registerAll(selenium);
+
+}
+
+function initialiseTestLoop() {
+    testLoop = new TestLoop(commandFactory);
+
+    testLoop.getCommandInterval = function() { return runInterval; };
+    testLoop.firstCommand = nextCommand;
+    testLoop.nextCommand = nextCommand;
+    testLoop.commandStarted = commandStarted;
+    testLoop.commandComplete = commandComplete;
+    testLoop.commandError = commandError;
+    testLoop.testComplete = testComplete;
+    testLoop.pause = function() {
+        document.getElementById('continueTest').disabled = false;
+    };
+    return testLoop;
+}
+
+function nextCommand() {
+    if (currentCommandRow >= inputTableRows.length - 1) {
+        return null;
+    }
+
+    currentCommandRow++;
+
+    var commandName = getCellText(currentCommandRow, 0);
+    var target = getCellText(currentCommandRow, 1);
+    var value = getCellText(currentCommandRow, 2);
+
+    var command = new SeleniumCommand(commandName, target, removeNbsp(value));
+    return command;
+}
+
+function removeNbsp(value)
+{
+    return value.replace(/\240/g, "");
+}
+
+function scrollIntoView(element) {
+    if (element.scrollIntoView) {
+        element.scrollIntoView(false);
+        return;
+    }
+    // TODO: work out how to scroll browsers that don't support
+    // scrollIntoView (like Konqueror)
+}
+
+function commandStarted() {
+    inputTableRows[currentCommandRow].bgColor = workingColor;
+    scrollIntoView(inputTableRows[currentCommandRow].cells[0]);
+    printMetrics();
+}
+
+function commandComplete(result) {
+    if (result.failed) {
+        setRowFailed(result.failureMessage, FAILURE);
+    } else if (result.passed) {
+        setRowPassed();
+    } else {
+        setRowWhite();
+    }
+}
+
+function commandError(errorMessage) {
+    setRowFailed(errorMessage, ERROR);
+}
+
+function setRowWhite() {
+    inputTableRows[currentCommandRow].bgColor = "white";
+}
+
+function setRowPassed() {
+    numCommandPasses += 1;
+
+    // Set cell background to green
+    inputTableRows[currentCommandRow].bgColor = passColor;
+}
+
+function setRowFailed(errorMsg, failureType) {
+    if (failureType == ERROR)
+            numCommandErrors += 1;
+    else if (failureType == FAILURE)
+            numCommandFailures += 1;
+
+    // Set cell background to red
+    inputTableRows[currentCommandRow].bgColor = failColor;
+
+    // Set error message
+    inputTableRows[currentCommandRow].cells[2].innerHTML = errorMsg;
+    inputTableRows[currentCommandRow].title = errorMsg;
+    testFailed = true;
+    suiteFailed = true;
+}
+
+function testComplete() {
+    if(testFailed) {
+        inputTableRows[0].bgColor = failColor;
+        numTestFailures += 1;
+    }
+    else {
+        inputTableRows[0].bgColor = passColor;
+        numTestPasses += 1;
+    }
+
+    printMetrics();
+
+    window.setTimeout("runNextTest()", 1);
+}
+
+function getCellText(rowNumber, columnNumber) {
+    var cell = inputTableRows[rowNumber].cells[columnNumber];
+    if (! cell.cachedText) {
+        cell.cachedText = getText(cell);
+    }
+    return cell.cachedText;
+}
+
+Selenium.prototype.doPause = function(waitTime) {
+    testLoop.pauseInterval = waitTime;
+};