selenium-webdriver 0.0.9 → 0.0.10

data/common/src/js/core/scripts/selenium-executionloop.js

@@ -0,0 +1,175 @@
+/*
+* 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.
+*/
+
+function TestLoop(commandFactory) {
+    this.commandFactory = commandFactory;
+}
+
+TestLoop.prototype = {
+
+    start : function() {
+        selenium.reset();
+        LOG.debug("currentTest.start()");
+        this.continueTest();
+    },
+
+    continueTest : function() {
+        /**
+         * Select the next command and continue the test.
+         */
+        LOG.debug("currentTest.continueTest() - acquire the next command");
+        if (! this.aborted) {
+            this.currentCommand = this.nextCommand();
+        }
+        if (! this.requiresCallBack) {
+            this.continueTestAtCurrentCommand();
+        } // otherwise, just finish and let the callback invoke continueTestAtCurrentCommand()
+    },
+
+    continueTestAtCurrentCommand : function() {
+        LOG.debug("currentTest.continueTestAtCurrentCommand()");
+        if (this.currentCommand) {
+            // TODO: rename commandStarted to commandSelected, OR roll it into nextCommand
+            this.commandStarted(this.currentCommand);
+            this._resumeAfterDelay();
+        } else {
+            this._testComplete();
+        }
+    },
+
+    _resumeAfterDelay : function() {
+        /**
+         * Pause, then execute the current command.
+         */
+
+        // Get the command delay. If a pauseInterval is set, use it once
+        // and reset it.  Otherwise, use the defined command-interval.
+        var delay = this.pauseInterval || this.getCommandInterval();
+        this.pauseInterval = undefined;
+
+        if (this.currentCommand.isBreakpoint || delay < 0) {
+            // Pause: enable the "next/continue" button
+            this.pause();
+        } else {
+            window.setTimeout(fnBind(this.resume, this), delay);
+        }
+    },
+
+    resume: function() {
+        /**
+         * Select the next command and continue the test.
+         */
+        LOG.debug("currentTest.resume() - actually execute");
+        try {
+            selenium.browserbot.runScheduledPollers();
+            this._executeCurrentCommand();
+            this.continueTestWhenConditionIsTrue();
+        } catch (e) {
+            if (!this._handleCommandError(e)) {
+                this.testComplete();
+            } else {
+                this.continueTest();
+            }
+        }
+    },
+
+    _testComplete : function() {
+        selenium.ensureNoUnhandledPopups();
+        this.testComplete();
+    },
+
+    _executeCurrentCommand : function() {
+        /**
+         * Execute the current command.
+         *
+         * @return a function which will be used to determine when
+         * execution can continue, or null if we can continue immediately
+         */
+        var command = this.currentCommand;
+        LOG.info("Executing: |" + command.command + " | " + command.target + " | " + command.value + " |");
+
+        var handler = this.commandFactory.getCommandHandler(command.command);
+        if (handler == null) {
+            throw new SeleniumError("Unknown command: '" + command.command + "'");
+        }
+
+        command.target = selenium.preprocessParameter(command.target);
+        command.value = selenium.preprocessParameter(command.value);
+        LOG.debug("Command found, going to execute " + command.command);
+        this.result = handler.execute(selenium, command);
+        
+
+        this.waitForCondition = this.result.terminationCondition;
+
+    },
+
+    _handleCommandError : function(e) {
+        if (!e.isSeleniumError) {
+            LOG.exception(e);
+            var msg = "Command execution failure. Please search the forum at http://clearspace.openqa.org for error details from the log window.";
+            msg += "  The error message is: " + extractExceptionMessage(e);
+            return this.commandError(msg);
+        } else {
+            LOG.error(e.message);
+            return this.commandError(e.message);
+        }
+    },
+
+    continueTestWhenConditionIsTrue: function () {
+        /**
+         * Busy wait for waitForCondition() to become true, and then carry
+         * on with test.  Fail the current test if there's a timeout or an
+         * exception.
+         */
+        //LOG.debug("currentTest.continueTestWhenConditionIsTrue()");
+        selenium.browserbot.runScheduledPollers();
+        try {
+            if (this.waitForCondition == null) {
+                LOG.debug("null condition; let's continueTest()");
+                LOG.debug("Command complete");
+                this.commandComplete(this.result);
+                this.continueTest();
+            } else if (this.waitForCondition()) {
+                LOG.debug("condition satisfied; let's continueTest()");
+                this.waitForCondition = null;
+                LOG.debug("Command complete");
+                this.commandComplete(this.result);
+                this.continueTest();
+            } else {
+                //LOG.debug("waitForCondition was false; keep waiting!");
+                window.setTimeout(fnBind(this.continueTestWhenConditionIsTrue, this), 10);
+            }
+        } catch (e) {
+            this.result = {};
+            this.result.failed = true;
+            this.result.failureMessage = extractExceptionMessage(e);
+            this.commandComplete(this.result);
+            this.continueTest();
+        }
+    },
+
+    pause : function() {},
+    nextCommand : function() {},
+    commandStarted : function() {},
+    commandComplete : function() {},
+    commandError : function() {},
+    testComplete : function() {},
+
+    getCommandInterval : function() {
+        return 0;
+    }
+
+}

data/common/src/js/core/scripts/selenium-logging.js

@@ -0,0 +1,148 @@
+/*
+ * 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.
+ */
+
+var Logger = function() {
+    this.logWindow = null;
+}
+Logger.prototype = {
+
+    logLevels: {
+        debug: 0,
+        info: 1,
+        warn: 2,
+        error: 3,
+        off: 999
+    },
+
+    pendingMessages: new Array(),
+    
+    threshold: "info",
+
+    setLogLevelThreshold: function(logLevel) {
+        this.threshold = logLevel;
+        var logWindow = this.getLogWindow()
+        if (logWindow && logWindow.setThresholdLevel) {
+            logWindow.setThresholdLevel(logLevel);
+        }
+        // NOTE: log messages will be discarded until the log window is
+        // fully loaded.
+    },
+
+    getLogWindow: function() {
+        if (this.logWindow && this.logWindow.closed) {
+            this.logWindow = null;
+        }
+        return this.logWindow;
+    },
+    
+    openLogWindow: function() {
+        this.logWindow = window.open(
+            getDocumentBase(document) + "SeleniumLog.html?startingThreshold="+this.threshold, "SeleniumLog",
+            "width=600,height=1000,bottom=0,right=0,status,scrollbars,resizable"
+        );
+        this.logWindow.moveTo(window.screenX + 1210, window.screenY + window.outerHeight - 1400);
+        if (browserVersion.appearsToBeBrokenInitialIE6) {
+	// I would really prefer for the message to immediately appear in the log window, the instant the user requests that the log window be 
+        	// visible.  But when I initially coded it this way, thou message simply didn't appear unless I stepped through the code with a debugger.  
+        	// So obviously there is some timing issue here which I don't have the patience to figure out.
+        	var pendingMessage = new LogMessage("warn", "You appear to be running an unpatched IE 6, which is not stable and can crash due to memory problems.  We recommend you run Windows update to install a more stable version of IE.");
+            this.pendingMessages.push(pendingMessage);
+        }
+        return this.logWindow;
+    },
+    
+    show: function() {
+        if (! this.getLogWindow()) {
+            this.openLogWindow();
+        }
+        setTimeout(function(){LOG.error("Log window displayed.  Logging events will now be recorded to this window.");}, 500);
+    },
+
+    logHook: function(logLevel, message) {
+    },
+
+    log: function(logLevel, message) {
+        if (this.logLevels[logLevel] < this.logLevels[this.threshold]) {
+            return;
+        }
+        this.logHook(logLevel, message);
+        var logWindow = this.getLogWindow();
+        if (logWindow) {
+            if (logWindow.append) {
+                if (logWindow.disabled) {
+                    logWindow.callBack = fnBind(this.setLogLevelThreshold, this);
+                    logWindow.enableButtons();
+                }
+                if (this.pendingMessages.length > 0) {
+                    logWindow.append("info("+(new Date().getTime())+"): Appending missed logging messages", "info");
+                    while (this.pendingMessages.length > 0) {
+                        var msg = this.pendingMessages.shift();
+                        logWindow.append(msg.type + "("+msg.timestamp+"): " + msg.msg, msg.type);
+                    }
+                    logWindow.append("info("+(new Date().getTime())+"): Done appending missed logging messages", "info");
+                }
+                logWindow.append(logLevel + "("+(new Date().getTime())+"): " + message, logLevel);
+            }
+        } else {
+            // TODO these logging messages are never flushed, which creates 
+            //   an enormous array of strings that never stops growing.
+            //   there should at least be a way to clear the messages!
+            this.pendingMessages.push(new LogMessage(logLevel, message));
+        }
+    },
+
+    close: function(message) {
+        if (this.logWindow != null) {
+            try {
+                this.logWindow.close();
+            } catch (e) {
+                // swallow exception
+                // the window is probably closed if we get an exception here
+            }
+            this.logWindow = null;
+        }
+    },
+
+    debug: function(message) {
+       this.log("debug", message);
+    },
+
+    info: function(message) {
+       this.log("info", message);
+    },
+
+    warn: function(message) {
+       this.log("warn", message);
+    },
+
+    error: function(message) {
+       this.log("error", message);
+    },
+
+    exception: function(exception) {
+        this.error("Unexpected Exception: " + extractExceptionMessage(exception));
+        this.error("Exception details: " + describe(exception, ', '));
+    }
+
+};
+
+var LOG = new Logger();
+
+var LogMessage = function(type, msg) {
+    this.type = type;
+    this.msg = msg;
+    this.timestamp = (new Date().getTime());
+}

data/common/src/js/core/scripts/selenium-remoterunner.js

@@ -0,0 +1,695 @@
+/*
+* Copyright 2005 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";
+errorColor = "#ffffff";
+workingColor = "#DEE7EC";
+doneColor = "#FFFFCC";
+
+var injectedSessionId;
+
+var postResult = "START";
+var debugMode = false;
+var relayToRC = null;
+var proxyInjectionMode = false;
+var uniqueId = 'sel_' + Math.round(100000 * Math.random());
+var seleniumSequenceNumber = 0;
+var cmd8 = "";
+var cmd7 = "";
+var cmd6 = "";
+var cmd5 = "";
+var cmd4 = "";
+var cmd3 = "";
+var cmd2 = "";
+var cmd1 = "";
+var lastCmd = "";
+var lastCmdTime = new Date();
+
+var RemoteRunnerOptions = classCreate();
+objectExtend(RemoteRunnerOptions.prototype, URLConfiguration.prototype);
+objectExtend(RemoteRunnerOptions.prototype, {
+    initialize: function() {
+        this._acquireQueryString();
+    },
+    isDebugMode: function() {
+        return this._isQueryParameterTrue("debugMode");
+    },
+
+    getContinue: function() {
+        return this._getQueryParameter("continue");
+    },
+
+    getDriverUrl: function() {
+        return this._getQueryParameter("driverUrl");
+    },
+
+    // requires per-session extension Javascript as soon as this Selenium
+    // instance becomes aware of the session identifier
+    getSessionId: function() {
+        var sessionId = this._getQueryParameter("sessionId");
+        requireExtensionJs(sessionId);
+        return sessionId;
+    },
+
+    _acquireQueryString: function () {
+        if (this.queryString) return;
+        if (browserVersion.isHTA) {
+            var args = this._extractArgs();
+            if (args.length < 2) return null;
+            this.queryString = args[1];
+        } else if (proxyInjectionMode) {
+            this.queryString = window.location.search.substr(1);
+        } else {
+            this.queryString = top.location.search.substr(1);
+        }
+    }
+
+});
+var runOptions;
+
+function runSeleniumTest() {
+    runOptions = new RemoteRunnerOptions();
+    var testAppWindow;
+
+    if (runOptions.isMultiWindowMode()) {
+        testAppWindow = openSeparateApplicationWindow('Blank.html', true);
+    } else if (sel$('selenium_myiframe') != null) {
+        var myiframe = sel$('selenium_myiframe');
+        if (myiframe) {
+            testAppWindow = myiframe.contentWindow;
+        }
+    }
+    else {
+        proxyInjectionMode = true;
+        testAppWindow = window;
+    }
+    selenium = Selenium.createForWindow(testAppWindow, proxyInjectionMode);
+    if (runOptions.getBaseUrl()) {
+        selenium.browserbot.baseUrl = runOptions.getBaseUrl();
+    }
+    if (!debugMode) {
+        debugMode = runOptions.isDebugMode();
+    }
+    if (proxyInjectionMode) {
+        LOG.logHook = logToRc;
+        selenium.browserbot._modifyWindow(testAppWindow);
+    }
+    else if (debugMode) {
+        LOG.logHook = logToRc;
+    }
+    window.selenium = selenium;
+
+    commandFactory = new CommandHandlerFactory();
+    commandFactory.registerAll(selenium);
+
+    currentTest = new RemoteRunner(commandFactory);
+
+    var doContinue = runOptions.getContinue();
+    if (doContinue != null) postResult = "OK";
+
+    currentTest.start();
+}
+
+function buildDriverUrl() {
+    var driverUrl = runOptions.getDriverUrl();
+    if (driverUrl != null) {
+        return driverUrl;
+    }
+    var s = window.location.href
+    var slashPairOffset = s.indexOf("//") + "//".length
+    var pathSlashOffset = s.substring(slashPairOffset).indexOf("/")
+    return s.substring(0, slashPairOffset + pathSlashOffset) + "/selenium-server/driver/";
+    //return "http://localhost" + uniqueId + "/selenium-server/driver/";
+}
+
+function logToRc(logLevel, message) {
+    if (debugMode) {
+        if (logLevel == null) {
+            logLevel = "debug";
+        }
+        sendToRCAndForget("logLevel=" + logLevel + ":" + message.replace(/[\n\r\015]/g, " ") + "\n", "logging=true");
+    }
+}
+
+function serializeString(name, s) {
+    return name + "=unescape(\"" + escape(s) + "\");";
+}
+
+function serializeObject(name, x)
+{
+    var s = '';
+
+    if (isArray(x))
+    {
+        s = name + "=new Array(); ";
+        var len = x["length"];
+        for (var j = 0; j < len; j++)
+        {
+            s += serializeString(name + "[" + j + "]", x[j]);
+        }
+    }
+    else if (typeof x == "string")
+    {
+        s = serializeString(name, x);
+    }
+    else
+    {
+        throw "unrecognized object not encoded: " + name + "(" + x + ")";
+    }
+    return s;
+}
+
+function relayBotToRC(s) {
+}
+
+// seems like no one uses this, but in fact it is called using eval from server-side PI mode code; however,
+// because multiple names can map to the same popup, assigning a single name confuses matters sometimes;
+// thus, I'm disabling this for now.  -Nelson 10/21/06
+function setSeleniumWindowName(seleniumWindowName) {
+//selenium.browserbot.getCurrentWindow()['seleniumWindowName'] = seleniumWindowName;
+}
+
+RemoteRunner = classCreate();
+objectExtend(RemoteRunner.prototype, new TestLoop());
+objectExtend(RemoteRunner.prototype, {
+    initialize : function(commandFactory) {
+        this.commandFactory = commandFactory;
+        this.requiresCallBack = true;
+        this.commandNode = null;
+        this.xmlHttpForCommandsAndResults = null;
+    },
+
+    nextCommand : function() {
+        var urlParms = "";
+        if (postResult == "START") {
+            urlParms += "seleniumStart=true";
+        }
+        this.xmlHttpForCommandsAndResults = XmlHttp.create();
+        sendToRC(postResult, urlParms, fnBind(this._HandleHttpResponse, this), this.xmlHttpForCommandsAndResults);
+    },
+
+    commandStarted : function(command) {
+        this.commandNode = document.createElement("div");
+        var cmdText = command.command + '(';
+        if (command.target != null && command.target != "") {
+            cmdText += command.target;
+            if (command.value != null && command.value != "") {
+                cmdText += ', ' + command.value;
+            }
+        }
+        if (cmdText.length > 70) {
+            cmdText = cmdText.substring(0, 70) + "...\n";
+        } else {
+            cmdText += ")\n";
+        }
+
+        if (cmdText == lastCmd) {
+	        var rightNow = new Date();
+	        var msSinceStart = rightNow.getTime() - lastCmdTime.getTime();
+	        var sinceStart = msSinceStart + "ms";
+	        if (msSinceStart > 1000) {
+		        sinceStart = Math.round(msSinceStart / 1000) + "s";
+		    }
+            cmd1 = "Same command (" + sinceStart + "): " + lastCmd;
+        } else {
+	        lastCmdTime = new Date();
+            cmd8 = cmd7;
+            cmd7 = cmd6;
+            cmd6 = cmd5;
+            cmd5 = cmd4;
+            cmd4 = cmd3;
+            cmd3 = cmd2;
+            cmd2 = cmd1;
+            cmd1 = cmdText;
+        }
+        lastCmd = cmdText;
+        
+        if (! proxyInjectionMode) {
+            var commandList = document.commands.commandList;
+            commandList.value = cmd8 + cmd7 + cmd6 + cmd5 + cmd4 + cmd3 + cmd2 + cmd1;
+            commandList.scrollTop = commandList.scrollHeight;
+        }
+    },
+
+    commandComplete : function(result) {
+
+        if (result.failed) {
+            if (postResult == "CONTINUATION") {
+                currentTest.aborted = true;
+            }
+            postResult = result.failureMessage;
+            this.commandNode.title = result.failureMessage;
+            this.commandNode.style.backgroundColor = failColor;
+        } else if (result.passed) {
+            postResult = "OK";
+            this.commandNode.style.backgroundColor = passColor;
+        } else {
+            if (result.result == null) {
+                postResult = "OK";
+            } else {
+                var actualResult = result.result;
+                actualResult = selArrayToString(actualResult);
+                postResult = "OK," + actualResult;
+            }
+            this.commandNode.style.backgroundColor = doneColor;
+        }
+    },
+
+    commandError : function(message) {
+        postResult = "ERROR: " + message;
+        this.commandNode.style.backgroundColor = errorColor;
+        this.commandNode.titcle = message;
+    },
+
+    testComplete : function() {
+        window.status = "Selenium Tests Complete, for this Test"
+        // Continue checking for new results
+        this.continueTest();
+        postResult = "START";
+    },
+
+    _HandleHttpResponse : function() {
+        // When request is completed
+        if (this.xmlHttpForCommandsAndResults.readyState == 4) {
+            // OK
+            if (this.xmlHttpForCommandsAndResults.status == 200) {
+            	if (this.xmlHttpForCommandsAndResults.responseText=="") {
+                    LOG.error("saw blank string xmlHttpForCommandsAndResults.responseText");
+                    return;
+                }
+                var command = this._extractCommand(this.xmlHttpForCommandsAndResults);
+                if (command.command == 'retryLast') {
+                    setTimeout(fnBind(function() {
+                        sendToRC("RETRY", "retry=true", fnBind(this._HandleHttpResponse, this), this.xmlHttpForCommandsAndResults, true);
+                    }, this), 1000);
+                } else {
+                    this.currentCommand = command;
+                    this.continueTestAtCurrentCommand();
+                }
+            }
+            // Not OK 
+            else {
+                var s = 'xmlHttp returned: ' + this.xmlHttpForCommandsAndResults.status + ": " + this.xmlHttpForCommandsAndResults.statusText;
+                LOG.error(s);
+                this.currentCommand = null;
+                setTimeout(fnBind(this.continueTestAtCurrentCommand, this), 2000);
+            }
+
+        }
+    },
+
+    _extractCommand : function(xmlHttp) {
+        var command, text, json;
+        text = command = xmlHttp.responseText;
+        if (/^json=/.test(text)) {
+            eval(text);
+            if (json.rest) {
+                eval(json.rest);
+            }
+            return json;
+        }
+        try {
+            var re = new RegExp("^(.*?)\n((.|[\r\n])*)");
+            if (re.exec(xmlHttp.responseText)) {
+                command = RegExp.$1;
+                var rest = RegExp.$2;
+                rest = rest.trim();
+                if (rest) {
+                    eval(rest);
+                }
+            }
+            else {
+                command = xmlHttp.responseText;
+            }
+        } catch (e) {
+            alert('could not get responseText: ' + e.message);
+        }
+        if (command.substr(0, '|testComplete'.length) == '|testComplete') {
+            return null;
+        }
+
+        return this._createCommandFromRequest(command);
+    },
+
+
+    _delay : function(millis) {
+        var startMillis = new Date();
+        while (true) {
+            milli = new Date();
+            if (milli - startMillis > millis) {
+                break;
+            }
+        }
+    },
+
+// Parses a URI query string into a SeleniumCommand object
+    _createCommandFromRequest : function(commandRequest) {
+        //decodeURIComponent doesn't strip plus signs
+        var processed = commandRequest.replace(/\+/g, "%20");
+        // strip trailing spaces
+        var processed = processed.replace(/\s+$/, "");
+        var vars = processed.split("&");
+        var cmdArgs = new Object();
+        for (var i = 0; i < vars.length; i++) {
+            var pair = vars[i].split("=");
+            cmdArgs[pair[0]] = pair[1];
+        }
+        var cmd = cmdArgs['cmd'];
+        var arg1 = cmdArgs['1'];
+        if (null == arg1) arg1 = "";
+        arg1 = decodeURIComponent(arg1);
+        var arg2 = cmdArgs['2'];
+        if (null == arg2) arg2 = "";
+        arg2 = decodeURIComponent(arg2);
+        if (cmd == null) {
+            throw new Error("Bad command request: " + commandRequest);
+        }
+        return new SeleniumCommand(cmd, arg1, arg2);
+    }
+
+})
+
+
+function sendToRC(dataToBePosted, urlParms, callback, xmlHttpObject, async) {
+    if (async == null) {
+        async = true;
+    }
+    if (xmlHttpObject == null) {
+        xmlHttpObject = XmlHttp.create();
+    }
+    var url = buildDriverUrl() + "?"
+    if (urlParms) {
+        url += urlParms;
+    }
+    url = addUrlParams(url);
+    url += "&sequenceNumber=" + seleniumSequenceNumber++;
+    
+    var postedData = "postedData=" + encodeURIComponent(dataToBePosted);
+
+    //xmlHttpObject.setRequestHeader("Content-Type", "application/x-www-form-urlencoded");
+    xmlHttpObject.open("POST", url, async);
+    if (callback) xmlHttpObject.onreadystatechange = callback;
+    xmlHttpObject.send(postedData);
+    return null;
+}
+
+function addUrlParams(url) {
+    return url + "&localFrameAddress=" + (proxyInjectionMode ? makeAddressToAUTFrame() : "top")
+    + getSeleniumWindowNameURLparameters()
+    + "&uniqueId=" + uniqueId
+    + buildDriverParams() + preventBrowserCaching()
+}
+
+function sendToRCAndForget(dataToBePosted, urlParams) {
+    var url;
+    if (!(browserVersion.isChrome || browserVersion.isHTA)) { 
+        // DGF we're behind a proxy, so we can send our logging message to literally any host, to avoid 2-connection limit
+        var protocol = "http:";
+        if (window.location.protocol == "https:") {
+            // DGF if we're in HTTPS, use another HTTPS url to avoid security warning
+            protocol = "https:";
+        }
+        // we don't choose a super large random value, but rather 1 - 16, because this matches with the pre-computed
+        // tunnels waiting on the Selenium Server side. This gives us higher throughput than the two-connection-per-host
+        // limitation, but doesn't require we generate an extremely large ammount of fake SSL certs either.
+        url = protocol + "//" + Math.floor(Math.random()* 16 + 1) + ".selenium.doesnotexist/selenium-server/driver/?" + urlParams;
+    } else {
+        url = buildDriverUrl() + "?" + urlParams;
+    }
+    url = addUrlParams(url);
+    
+    var method = "GET";
+    if (method == "POST") {
+        // DGF submit a request using an iframe; we can't see the response, but we don't need to
+        // TODO not using this mechanism because it screws up back-button
+        var loggingForm = document.createElement("form");
+        loggingForm.method = "POST";
+        loggingForm.action = url;
+        loggingForm.target = "seleniumLoggingFrame";
+        var postedDataInput = document.createElement("input");
+        postedDataInput.type = "hidden";
+        postedDataInput.name = "postedData";
+        postedDataInput.value = dataToBePosted;
+        loggingForm.appendChild(postedDataInput);
+        document.body.appendChild(loggingForm);
+        loggingForm.submit();
+        document.body.removeChild(loggingForm);
+    } else {
+        var postedData = "&postedData=" + encodeURIComponent(dataToBePosted);
+        var scriptTag = document.createElement("script");
+        scriptTag.src = url + postedData;
+        document.body.appendChild(scriptTag);
+        document.body.removeChild(scriptTag);
+    }
+}
+
+function buildDriverParams() {
+    var params = "";
+
+    var sessionId = runOptions.getSessionId();
+    if (sessionId == undefined) {
+        sessionId = injectedSessionId;
+    }
+    if (sessionId != undefined) {
+        params = params + "&sessionId=" + sessionId;
+    }
+    return params;
+}
+
+function preventBrowserCaching() {
+    var t = (new Date()).getTime();
+    return "&counterToMakeURsUniqueAndSoStopPageCachingInTheBrowser=" + t;
+}
+
+//
+// Return URL parameters pertaining to the name(s?) of the current window
+//
+// In selenium, the main (i.e., first) window's name is a blank string.
+//
+// Additional pop-ups are associated with either 1.) the name given by the 2nd parameter to window.open, or 2.) the name of a
+// property on the opening window which points at the window.
+//
+// An example of #2: if window X contains JavaScript as follows:
+//
+// 	var windowABC = window.open(...)
+//
+// Note that the example JavaScript above is equivalent to
+//
+// 	window["windowABC"] = window.open(...)
+//
+function getSeleniumWindowNameURLparameters() {
+    var w = (proxyInjectionMode ? selenium.browserbot.getCurrentWindow() : window).top;
+    var s = "&seleniumWindowName=";
+    if (w.opener == null) {
+        return s;
+    }
+    if (w["seleniumWindowName"] == null) {
+        if (w.name) {
+            w["seleniumWindowName"] = w.name;
+        } else {
+    	    w["seleniumWindowName"] = 'generatedSeleniumWindowName_' + Math.round(100000 * Math.random());
+    	}
+    }
+    s += w["seleniumWindowName"];
+    var windowOpener = w.opener;
+    for (key in windowOpener) {
+        var val = null;
+        try {
+    	    val = windowOpener[key];
+        }
+        catch(e) {
+        }
+        if (val==w) {
+	    s += "&jsWindowNameVar=" + key;			// found a js variable in the opener referring to this window
+        }
+    }
+    return s;
+}
+
+// construct a JavaScript expression which leads to my frame (i.e., the frame containing the window
+// in which this code is operating)
+function makeAddressToAUTFrame(w, frameNavigationalJSexpression)
+{
+    if (w == null)
+    {
+        w = top;
+        frameNavigationalJSexpression = "top";
+    }
+
+    if (w == selenium.browserbot.getCurrentWindow())
+    {
+        return frameNavigationalJSexpression;
+    }
+    for (var j = 0; j < w.frames.length; j++)
+    {
+        var t = makeAddressToAUTFrame(w.frames[j], frameNavigationalJSexpression + ".frames[" + j + "]");
+        if (t != null)
+        {
+            return t;
+        }
+    }
+    return null;
+}
+
+Selenium.prototype.doSetContext = function(context) {
+    /**
+   * Writes a message to the status bar and adds a note to the browser-side
+   * log.
+   *
+   * @param context
+   *            the message to be sent to the browser
+   */
+    //set the current test title
+    var ctx = document.getElementById("context");
+    if (ctx != null) {
+        ctx.innerHTML = context;
+    }
+};
+
+/**
+ * Adds a script tag referencing a specially-named user extensions "file". The
+ * resource handler for this special file (which won't actually exist) will use
+ * the session ID embedded in its name to retrieve per-session specified user
+ * extension javascript.
+ *
+ * @param sessionId
+ */
+function requireExtensionJs(sessionId) {
+    var src = 'scripts/user-extensions.js[' + sessionId + ']';
+    if (document.getElementById(src) == null) {
+        var scriptTag = document.createElement('script');
+        scriptTag.language = 'JavaScript';
+        scriptTag.type = 'text/javascript';
+        scriptTag.src = src;
+        scriptTag.id = src;
+        var headTag = document.getElementsByTagName('head')[0];
+        headTag.appendChild(scriptTag);
+    }
+}
+
+Selenium.prototype.doAttachFile = function(fieldLocator,fileLocator) {
+   /**
+   * Sets a file input (upload) field to the file listed in fileLocator
+   *
+   *  @param fieldLocator an <a href="#locators">element locator</a>
+   *  @param fileLocator a URL pointing to the specified file. Before the file
+   *  can be set in the input field (fieldLocator), Selenium RC may need to transfer the file  
+   *  to the local machine before attaching the file in a web page form. This is common in selenium
+   *  grid configurations where the RC server driving the browser is not the same
+   *  machine that started the test.
+   *
+   *  Supported Browsers: Firefox ("*chrome") only.
+   *   
+   */
+   // This doesn't really do anything on the JS side; we let the Selenium Server take care of this for us! 
+};
+
+Selenium.prototype.doCaptureScreenshot = function(filename) {
+    /**
+    * Captures a PNG screenshot to the specified file.
+    *
+    * @param filename the absolute path to the file to be written, e.g. "c:\blah\screenshot.png"
+    */
+    // This doesn't really do anything on the JS side; we let the Selenium Server take care of this for us!
+};
+
+Selenium.prototype.doCaptureScreenshotToString = function() {
+    /**
+    * Capture a PNG screenshot.  It then returns the file as a base 64 encoded string. 
+    * 
+    * @return string The base 64 encoded string of the screen shot (PNG file)
+    */
+    // This doesn't really do anything on the JS side; we let the Selenium Server take care of this for us!
+};
+
+Selenium.prototype.doCaptureEntirePageScreenshotToString = function(kwargs) {
+    /**
+    * Downloads a screenshot of the browser current window canvas to a 
+    * based 64 encoded PNG file. The <em>entire</em> windows canvas is captured,
+    * including parts rendered outside of the current view port.
+    *
+	* Currently this only works in Mozilla and when running in chrome mode. 
+    * 
+    * @param kwargs  A kwargs string that modifies the way the screenshot is captured. Example: "background=#CCFFDD". This may be useful to set for capturing screenshots of less-than-ideal layouts, for example where absolute positioning causes the calculation of the canvas dimension to fail and a black background is exposed  (possibly obscuring black text).
+    *
+    * @return string The base 64 encoded string of the page screenshot (PNG file)
+    */
+    // This doesn't really do anything on the JS side; we let the Selenium Server take care of this for us!
+};
+
+Selenium.prototype.doShutDownSeleniumServer = function(keycode) {
+    /**
+    * Kills the running Selenium Server and all browser sessions.  After you run this command, you will no longer be able to send
+    * commands to the server; you can't remotely start the server once it has been stopped.  Normally
+    * you should prefer to run the "stop" command, which terminates the current browser session, rather than 
+    * shutting down the entire server.
+    *
+    */
+    // This doesn't really do anything on the JS side; we let the Selenium Server take care of this for us!
+};
+
+Selenium.prototype.doRetrieveLastRemoteControlLogs = function() {
+    /**
+    * Retrieve the last messages logged on a specific remote control. Useful for error reports, especially
+    * when running multiple remote controls in a distributed environment. The maximum number of log messages
+    * that can be retrieve is configured on remote control startup.
+    *
+    * @return string The last N log messages as a multi-line string.
+    */
+    // This doesn't really do anything on the JS side; we let the Selenium Server take care of this for us!
+};
+
+Selenium.prototype.doKeyDownNative = function(keycode) {
+    /**
+    * Simulates a user pressing a key (without releasing it yet) by sending a native operating system keystroke.
+    * This function uses the java.awt.Robot class to send a keystroke; this more accurately simulates typing
+    * a key on the keyboard.  It does not honor settings from the shiftKeyDown, controlKeyDown, altKeyDown and
+    * metaKeyDown commands, and does not target any particular HTML element.  To send a keystroke to a particular
+    * element, focus on the element first before running this command.
+    *
+    * @param keycode an integer keycode number corresponding to a java.awt.event.KeyEvent; note that Java keycodes are NOT the same thing as JavaScript keycodes!
+    */
+    // This doesn't really do anything on the JS side; we let the Selenium Server take care of this for us!
+};
+
+Selenium.prototype.doKeyUpNative = function(keycode) {
+    /**
+    * Simulates a user releasing a key by sending a native operating system keystroke.
+    * This function uses the java.awt.Robot class to send a keystroke; this more accurately simulates typing
+    * a key on the keyboard.  It does not honor settings from the shiftKeyDown, controlKeyDown, altKeyDown and
+    * metaKeyDown commands, and does not target any particular HTML element.  To send a keystroke to a particular
+    * element, focus on the element first before running this command.
+    *
+    * @param keycode an integer keycode number corresponding to a java.awt.event.KeyEvent; note that Java keycodes are NOT the same thing as JavaScript keycodes!
+    */
+    // This doesn't really do anything on the JS side; we let the Selenium Server take care of this for us!
+};
+
+Selenium.prototype.doKeyPressNative = function(keycode) {
+    /**
+    * Simulates a user pressing and releasing a key by sending a native operating system keystroke.
+    * This function uses the java.awt.Robot class to send a keystroke; this more accurately simulates typing
+    * a key on the keyboard.  It does not honor settings from the shiftKeyDown, controlKeyDown, altKeyDown and
+    * metaKeyDown commands, and does not target any particular HTML element.  To send a keystroke to a particular
+    * element, focus on the element first before running this command.
+    *
+    * @param keycode an integer keycode number corresponding to a java.awt.event.KeyEvent; note that Java keycodes are NOT the same thing as JavaScript keycodes!
+    */
+    // This doesn't really do anything on the JS side; we let the Selenium Server take care of this for us!
+};
+