rainux-selenium-webdriver 0.0.17

data/common/src/js/jsunit/licenses/mpl-tri-license-c.txt

@@ -0,0 +1,35 @@
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (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.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is __________________________________________.
+ *
+ * The Initial Developer of the Original Code is
+ * ____________________________________________.
+ * Portions created by the Initial Developer are Copyright (C) 2___
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either the GNU General Public License Version 2 or later (the "GPL"), or
+ * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */

data/common/src/js/jsunit/licenses/mpl-tri-license-html.txt

@@ -0,0 +1,35 @@
+<!-- ***** BEGIN LICENSE BLOCK *****
+   - Version: MPL 1.1/GPL 2.0/LGPL 2.1
+   -
+   - The contents of this file are subject to the Mozilla Public License Version
+   - 1.1 (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.mozilla.org/MPL/
+   -
+   - Software distributed under the License is distributed on an "AS IS" basis,
+   - WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+   - for the specific language governing rights and limitations under the
+   - License.
+   -
+   - The Original Code is __________________________________________.
+   -
+   - The Initial Developer of the Original Code is
+   - ____________________________________________.
+   - Portions created by the Initial Developer are Copyright (C) 2___
+   - the Initial Developer. All Rights Reserved.
+   -
+   - Contributor(s):
+   -
+   - Alternatively, the contents of this file may be used under the terms of
+   - either the GNU General Public License Version 2 or later (the "GPL"), or
+   - the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+   - in which case the provisions of the GPL or the LGPL are applicable instead
+   - of those above. If you wish to allow use of your version of this file only
+   - under the terms of either the GPL or the LGPL, and not to allow others to
+   - use your version of this file under the terms of the MPL, indicate your
+   - decision by deleting the provisions above and replace them with the notice
+   - and other provisions required by the LGPL or the GPL. If you do not delete
+   - the provisions above, a recipient may use your version of this file under
+   - the terms of any one of the MPL, the GPL or the LGPL.
+   -
+   - ***** END LICENSE BLOCK ***** -->

data/common/src/js/jsunit/readme.txt

@@ -0,0 +1,19 @@
+JsUnit
+Copyright (C) 2001-6 Edward Hieatt, edward@jsunit.net
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation; either version 2
+of the License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+Please see http://www.jsunit.net/ for JsUnit documentation and
+the "licenses" directory for license information.

data/common/src/js/jsunit/testRunner.html

@@ -0,0 +1,167 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Frameset//EN" "http://www.w3.org/TR/html4/frameset.dtd">
+<html>
+
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+<title>JsUnit Test Runner</title>
+<script language="JavaScript" type="text/javascript" src="app/xbDebug.js"></script>
+<script language="JavaScript" type="text/javascript" src="app/jsUnitCore.js"></script>
+<script language="JavaScript" type="text/javascript">
+    var DEFAULT_TEST_FRAME_HEIGHT = 250;
+
+    function jsUnitParseParms(string) {
+        var i;
+        var searchString = unescape(string);
+        var parameterHash = new Object();
+
+        if (!searchString) {
+            return parameterHash;
+        }
+
+        i = searchString.indexOf('?');
+        if (i != -1) {
+            searchString = searchString.substring(i + 1);
+        }
+
+        var parmList = searchString.split('&');
+        var a;
+        for (i = 0; i < parmList.length; i++) {
+            a = parmList[i].split('=');
+            a[0] = a[0].toLowerCase();
+            if (a.length > 1) {
+                parameterHash[a[0]] = a[1];
+            }
+            else {
+                parameterHash[a[0]] = true;
+            }
+        }
+        return parameterHash;
+    }
+
+    function jsUnitConstructTestParms() {
+        var p;
+        var parms = '';
+
+        for (p in jsUnitParmHash) {
+            var value = jsUnitParmHash[p];
+
+            if (!value ||
+                p == 'testpage' ||
+                p == 'autorun' ||
+                p == 'submitresults' ||
+                p == 'showtestframe' ||
+                p == 'resultid') {
+                continue;
+            }
+
+            if (parms) {
+                parms += '&';
+            }
+
+            parms += p;
+
+            if (typeof(value) != 'boolean') {
+                parms += '=' + value;
+            }
+        }
+        return escape(parms);
+    }
+
+    var jsUnitParmHash = jsUnitParseParms(document.location.search);
+
+    // set to true to turn debugging code on, false to turn it off.
+    xbDEBUG.on = jsUnitGetParm('debug') ? true : false;
+</script>
+
+<script language="JavaScript" type="text/javascript" src="app/jsUnitTestManager.js"></script>
+<script language="JavaScript" type="text/javascript" src="app/jsUnitTracer.js"></script>
+<script language="JavaScript" type="text/javascript" src="app/jsUnitTestSuite.js"></script>
+<script language="JavaScript" type="text/javascript">
+
+    var testManager;
+    var utility;
+    var tracer;
+
+
+    if (!Array.prototype.push) {
+        Array.prototype.push = function (anObject) {
+            this[this.length] = anObject;
+        }
+    }
+
+    if (!Array.prototype.pop) {
+        Array.prototype.pop = function () {
+            if (this.length > 0) {
+                delete this[this.length - 1];
+                this.length--;
+            }
+        }
+    }
+
+    function shouldKickOffTestsAutomatically() {
+        return jsUnitGetParm('autorun') == "true";
+    }
+
+    function shouldShowTestFrame() {
+        return jsUnitGetParm('showtestframe');
+    }
+
+    function shouldSubmitResults() {
+        return jsUnitGetParm('submitresults');
+    }
+
+    function getResultId() {
+        if (jsUnitGetParm('resultid'))
+            return jsUnitGetParm('resultid');
+        return "";
+    }
+
+    function submitResults() {
+        window.mainFrame.mainData.document.testRunnerForm.runButton.disabled = true;
+        window.mainFrame.mainResults.populateHeaderFields(getResultId(), navigator.userAgent, JSUNIT_VERSION, testManager.resolveUserEnteredTestFileName());
+        window.mainFrame.mainResults.submitResults();
+    }
+
+    function wasResultUrlSpecified() {
+        return shouldSubmitResults() && jsUnitGetParm('submitresults') != 'true';
+    }
+
+    function getSpecifiedResultUrl() {
+        return jsUnitGetParm('submitresults');
+    }
+
+    function init() {
+        var testRunnerFrameset = document.getElementById('testRunnerFrameset');
+        if (shouldShowTestFrame() && testRunnerFrameset) {
+            var testFrameHeight;
+            if (jsUnitGetParm('showtestframe') == 'true')
+                testFrameHeight = DEFAULT_TEST_FRAME_HEIGHT;
+            else
+                testFrameHeight = jsUnitGetParm('showtestframe');
+            testRunnerFrameset.rows = '*,0,' + testFrameHeight;
+        }
+        testManager = new jsUnitTestManager();
+        tracer = new JsUnitTracer(testManager);
+        if (shouldKickOffTestsAutomatically()) {
+            window.mainFrame.mainData.kickOffTests();
+        }
+    }
+
+
+</script>
+</head>
+
+<frameset id="testRunnerFrameset" rows="*,0,0" border="0" onload="init()">
+
+    <frame frameborder="0" name="mainFrame" src="./app/main-frame.html">
+    <frame frameborder="0" name="documentLoader" src="./app/main-loader.html">
+    <frame frameborder="0" name="testContainer" src="./app/testContainer.html">
+
+    <noframes>
+        <body>
+        <p>Sorry, JsUnit requires support for frames.</p>
+        </body>
+    </noframes>
+</frameset>
+
+</html>

data/common/src/js/jsunit/version.txt

@@ -0,0 +1 @@
+JsUnit 22.2 alpha 11

data/common/src/js/key.js

@@ -0,0 +1,117 @@
+/** @license
+Copyright 2007-2009 WebDriver committers
+Copyright 2007-2009 Google 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.
+*/
+
+goog.provide('webdriver.Key');
+
+goog.require('goog.array');
+
+
+/**
+ * Representations of pressable keys that aren't text.  These are stored in
+ * the Unicode PUA (Private Use Area) code points, 0xE000-0xF8FF.  Refer to
+ * http://www.google.com.au/search?&q=unicode+pua&btnG=Search
+ * @enum {string}
+ */
+webdriver.Key = {
+  NULL:         '\uE000',
+  CANCEL:       '\uE001',  // ^break
+  HELP:         '\uE002',
+  BACK_SPACE:   '\uE003',
+  TAB:          '\uE004',
+  CLEAR:        '\uE005',
+  RETURN:       '\uE006',
+  ENTER:        '\uE007',
+  SHIFT:        '\uE008',
+  LEFT_SHIFT:   '\uE008', // alias
+  CONTROL:      '\uE009',
+  LEFT_CONTROL: '\uE009', // alias
+  ALT:          '\uE00A',
+  LEFT_ALT:     '\uE00A', // alias
+  PAUSE:        '\uE00B',
+  ESCAPE:       '\uE00C',
+  SPACE:        '\uE00D',
+  PAGE_UP:      '\uE00E',
+  PAGE_DOWN:    '\uE00F',
+  END:          '\uE010',
+  HOME:         '\uE011',
+  LEFT:         '\uE012',
+  ARROW_LEFT:   '\uE012', // alias
+  UP:           '\uE013',
+  ARROW_UP:     '\uE013', // alias
+  RIGHT:        '\uE014',
+  ARROW_RIGHT:  '\uE014', // alias
+  DOWN:         '\uE015',
+  ARROW_DOWN:   '\uE015', // alias
+  INSERT:       '\uE016',
+  DELETE:       '\uE017',
+  SEMICOLON:    '\uE018',
+  EQUALS:       '\uE019',
+
+  NUMPAD0:      '\uE01A',  // number pad keys
+  NUMPAD1:      '\uE01B',
+  NUMPAD2:      '\uE01C',
+  NUMPAD3:      '\uE01D',
+  NUMPAD4:      '\uE01E',
+  NUMPAD5:      '\uE01F',
+  NUMPAD6:      '\uE020',
+  NUMPAD7:      '\uE021',
+  NUMPAD8:      '\uE022',
+  NUMPAD9:      '\uE023',
+  MULTIPLY:     '\uE024',
+  ADD:          '\uE025',
+  SEPARATOR:    '\uE026',
+  SUBTRACT:     '\uE027',
+  DECIMAL:      '\uE028',
+  DIVIDE:       '\uE029',
+
+  F1:           '\uE031',  // function keys
+  F2:           '\uE032',
+  F3:           '\uE033',
+  F4:           '\uE034',
+  F5:           '\uE035',
+  F6:           '\uE036',
+  F7:           '\uE037',
+  F8:           '\uE038',
+  F9:           '\uE039',
+  F10:          '\uE03A',
+  F11:          '\uE03B',
+  F12:          '\uE03C',
+
+  COMMAND:      '\uE03D',  // Apple command key
+  META:         '\uE03D'   // alias for Windows key
+};
+
+/**
+* Simulate pressing many keys at once in a "chord". Takes a sequence of
+* Keys.XXXX or strings; appends each of the values to a string, and adds the
+* chord termination key (Keys.NULL) and returns the resultant string.
+*
+* Note: when the low-level webdriver key handlers see Keys.NULL, active
+* modifier keys (CTRL/ALT/SHIFT/etc) release via a keyup event.
+*
+* @param {string|webdriver.Key} var_args The key sequence to concatenate.
+* @see http://code.google.com/p/webdriver/issues/detail?id=79
+*/
+webdriver.Key.chord = function(var_args) {
+  var sequence = goog.array.reduce(
+      goog.array.slice(arguments, 0),
+      function(str, key) {
+        return str + key;
+      }, '');
+  sequence += webdriver.Key.NULL;
+  return sequence;
+};

data/common/src/js/localcommandprocessor.js

@@ -0,0 +1,185 @@
+/** @license
+Copyright 2007-2009 WebDriver committers
+Copyright 2007-2009 Google 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.
+*/
+
+/**
+ * @fileoverview Defines a command processor that uses a browser
+ * extension/plugin object available to the Javascript on the page.
+ * @author jmleyba@gmail.com (Jason Leyba)
+ */
+
+goog.provide('webdriver.LocalCommandProcessor');
+
+goog.require('goog.array');
+goog.require('goog.debug.Logger');
+goog.require('goog.dom');
+goog.require('goog.events');
+goog.require('goog.json');
+goog.require('goog.object');
+goog.require('webdriver.AbstractCommandProcessor');
+goog.require('webdriver.CommandName');
+goog.require('webdriver.Context');
+goog.require('webdriver.Response');
+
+
+/**
+ * Command processor that uses a browser extension/plugin exposed to the page
+ * for executing WebDriver commands.
+ * @param {goog.dom.DomHelper} opt_dom The DomHelper for this instance to use;
+ *     defaults to a DomHelper for the current document.
+ * @constructor
+ * @extends {webdriver.AbstractCommandProcessor}
+ */
+webdriver.LocalCommandProcessor = function(opt_dom) {
+  webdriver.AbstractCommandProcessor.call(this);
+  // TODO(jmleyba): IE, Chrome, et al. support
+
+  /**
+   * The DomHelper for this instance to use.
+   * @type {goog.dom.DomHelper}
+   * @private
+   */
+  this.dom_ = opt_dom || goog.dom.getDomHelper();
+
+  /**
+   * The element to use for communicating with the extension.
+   * @type {Element}
+   * @private
+   */
+  this.documentElement_ = this.dom_.getDocument().documentElement;
+
+  // Verify the extension is installed by checking for the webdriver attribute
+  // on the documentElement.
+  var webdriverAttribute = this.documentElement_.getAttribute('webdriver');
+  if (!webdriverAttribute) {
+    throw Error(
+        'The current browser does not support a LocalCommandProcessor');
+  }
+};
+goog.inherits(webdriver.LocalCommandProcessor,
+              webdriver.AbstractCommandProcessor);
+
+
+/**
+ * The custom event types used to communicate with the browser extension.
+ * @enum {string}
+ */
+webdriver.LocalCommandProcessor.EventType_ = {
+  COMMAND: 'webdriverCommand',
+  RESPONSE: 'webdriverResponse'
+};
+
+
+/**
+ * The attributes used to store information passed to the browser extension.
+ * @enum {string}
+ */
+webdriver.LocalCommandProcessor.MessageAttribute_ = {
+  COMMAND: 'command',
+  RESPONSE: 'response'
+};
+
+
+/**
+ * @override
+ */
+webdriver.LocalCommandProcessor.prototype.disposeInternal = function() {
+  goog.events.removeAll(this.documentElement_,
+      webdriver.LocalCommandProcessor.EventType_.RESPONSE);
+  webdriver.LocalCommandProcessor.superClass_.disposeInternal.call(this);
+};
+
+
+/**
+ * Event handler for command responses.
+ * @param {webdriver.Command} command The initiating command.
+ * @param {Event} e The response event. The target should be a node with a
+ *     {@code response} attribute.
+ */
+webdriver.LocalCommandProcessor.onResponse_ = function(command, e) {
+  // It is technically possible that the response could be for a different
+  // command, but this should be prevented by code higher in the WebDriverJS
+  // stack, so we don't do any error checking here.
+  if (e.type != webdriver.LocalCommandProcessor.EventType_.RESPONSE) {
+    throw Error('Not a response event!');
+  }
+
+  var jsonResponse = e.target.getAttribute(
+      webdriver.LocalCommandProcessor.MessageAttribute_.RESPONSE);
+  if (!jsonResponse) {
+    throw Error('Empty response!');
+  }
+
+  var rawResponse = goog.json.parse(jsonResponse);
+  goog.debug.Logger.getLogger('webdriver.LocalCommandProcessor').fine(
+      'receiving:\n' + jsonResponse);
+
+  var response = new webdriver.Response(
+      rawResponse['isError'],
+      webdriver.Context.fromString(rawResponse['context']),
+      rawResponse['response']);
+
+  // Only code in this file should be dispatching command events and listening
+  // for response events, so this is safe. If someone else decided to attach a
+  // listener anyway, tough luck.
+  goog.events.removeAll(
+      e.target, webdriver.LocalCommandProcessor.EventType_.RESPONSE);
+  command.setResponse(response);
+};
+
+
+/**
+ * @override
+ */
+webdriver.LocalCommandProcessor.prototype.dispatchDriverCommand = function(
+    command) {
+  if (command.getName() == webdriver.CommandName.SEND_KEYS) {
+    command.setParameters(command.getParameters().join(''));
+  }
+
+  var jsonCommand = {
+    'commandName': command.getName(),
+    'context': command.getDriver().getContext().toString(),
+    'parameters': command.getParameters()
+  };
+
+  if (command.element) {
+    try {
+      jsonCommand['elementId'] = command.element.getId().getValue();
+    } catch (ex) {
+      window.console.dir(command);
+      throw ex;
+    }
+  }
+
+  jsonCommand = goog.json.serialize(jsonCommand);
+  goog.debug.Logger.getLogger('webdriver.LocalCommandProcessor').fine(
+      'sending:\n' + jsonCommand);
+
+  this.documentElement_.setAttribute(
+      webdriver.LocalCommandProcessor.MessageAttribute_.COMMAND,
+      jsonCommand);
+
+  goog.events.listen(this.documentElement_,
+      webdriver.LocalCommandProcessor.EventType_.RESPONSE,
+      goog.bind(webdriver.LocalCommandProcessor.onResponse_, null, command));
+
+  var commandEvent = this.dom_.getDocument().createEvent('Event');
+  commandEvent.initEvent(
+      webdriver.LocalCommandProcessor.EventType_.COMMAND,
+      /*canBubble=*/true, /*cancelable=*/true);
+  this.documentElement_.dispatchEvent(commandEvent);
+};