2 files changed, 655 insertions, 0 deletions
diff --git a/node_modules/selenium-webdriver/testing/assert.js b/node_modules/selenium-webdriver/testing/assert.js
new file mode 100644
index 000000000..253aca034
--- /dev/null
+++ b/node_modules/selenium-webdriver/testing/assert.js
@@ -0,0 +1,378 @@
+// Licensed to the Software Freedom Conservancy (SFC) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The SFC licenses this file
+// to you 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 library that simplifies writing assertions against
+ * promised values.
+ *
+ * > <hr>
+ * > __NOTE:__ This module is considered experimental and is subject to
+ * > change, or removal, at any time!
+ * > <hr>
+ *
+ * Sample usage:
+ *
+ *     var driver = new webdriver.Builder().build();
+ *     driver.get('http://www.google.com');
+ *
+ *     assert(driver.getTitle()).equalTo('Google');
+ */
+
+'use strict';
+
+const assert = require('assert');
+
+function trueType(v) {
+  if (v === null) {
+    return 'null';
+  }
+
+  let type = typeof v;
+  if (type === 'object') {
+    if (Array.isArray(v)) {
+      type = 'array';
+    }
+  }
+  return type;
+}
+
+
+function checkType(v, want) {
+  let got = trueType(v);
+  if (got !== want) {
+    throw new TypeError('require ' + want + ', but got ' + got);
+  }
+  return v;
+}
+
+const checkNumber = v => checkType(v, 'number');
+const checkFunction = v => checkType(v, 'function');
+const checkString = v => checkType(v, 'string');
+
+const isFunction = v => trueType(v) === 'function';
+const isNumber = v => trueType(v) === 'number';
+const isObject = v => trueType(v) === 'object';
+const isString = v => trueType(v) === 'string';
+
+
+function describe(value) {
+  let ret;
+  try {
+    ret = `<${String(value)}>`;
+  } catch (e) {
+    ret = `<toString failed: ${e.message}>`;
+  }
+
+  if (null !== value && void(0) !== value) {
+    ret += ` (${trueType(value)})`;
+  }
+
+  return ret;
+}
+
+
+function evaluate(value, predicate) {
+  if (isObject(value) && isFunction(value.then)) {
+    return value.then(predicate);
+  }
+  predicate(value);
+}
+
+
+/**
+ * @private
+ */
+class Assertion {
+  /**
+   * @param {?} subject The subject of this assertion.
+   * @param {boolean=} opt_invert Whether to invert any assertions performed by
+   *     this instance.
+   */
+  constructor(subject, opt_invert) {
+    /** @private {?} */
+    this.subject_ = subject;
+    /** @private {boolean} */
+    this.invert_ = !!opt_invert;
+  }
+
+  /**
+   * @param {number} expected The minimum permissible value (inclusive).
+   * @param {string=} opt_message An optional failure message.
+   * @return {(Promise|undefined)} The result of this assertion, if the subject
+   *     is a promised-value. Otherwise, the assertion is performed immediately
+   *     and nothing is returned.
+   */
+  atLeast(expected, opt_message) {
+    checkNumber(expected);
+    return evaluate(this.subject_, function(actual) {
+      if (!isNumber(actual) || actual < expected) {
+        assert.fail(actual, expected, opt_message, '>=');
+      }
+    });
+  }
+
+  /**
+   * @param {number} expected The maximum permissible value (inclusive).
+   * @param {string=} opt_message An optional failure message.
+   * @return {(Promise|undefined)} The result of this assertion, if the subject
+   *     is a promised-value. Otherwise, the assertion is performed immediately
+   *     and nothing is returned.
+   */
+  atMost(expected, opt_message) {
+    checkNumber(expected);
+    return evaluate(this.subject_, function (actual) {
+      if (!isNumber(actual) || actual > expected) {
+        assert.fail(actual, expected, opt_message, '<=');
+      }
+    });
+  }
+
+  /**
+   * @param {number} expected The maximum permissible value (exclusive).
+   * @param {string=} opt_message An optional failure message.
+   * @return {(Promise|undefined)} The result of this assertion, if the subject
+   *     is a promised-value. Otherwise, the assertion is performed immediately
+   *     and nothing is returned.
+   */
+  greaterThan(expected, opt_message) {
+    checkNumber(expected);
+    return evaluate(this.subject_, function(actual) {
+      if (!isNumber(actual) || actual <= expected) {
+        assert.fail(actual, expected, opt_message, '>');
+      }
+    });
+  }
+
+  /**
+   * @param {number} expected The minimum permissible value (exclusive).
+   * @param {string=} opt_message An optional failure message.
+   * @return {(Promise|undefined)} The result of this assertion, if the subject
+   *     is a promised-value. Otherwise, the assertion is performed immediately
+   *     and nothing is returned.
+   */
+  lessThan(expected, opt_message) {
+    checkNumber(expected);
+    return evaluate(this.subject_,  function (actual) {
+      if (!isNumber(actual) || actual >= expected) {
+        assert.fail(actual, expected, opt_message, '<');
+      }
+    });
+  }
+
+  /**
+   * @param {number} expected The desired value.
+   * @param {number} epsilon The maximum distance from the desired value.
+   * @param {string=} opt_message An optional failure message.
+   * @return {(Promise|undefined)} The result of this assertion, if the subject
+   *     is a promised-value. Otherwise, the assertion is performed immediately
+   *     and nothing is returned.
+   */
+  closeTo(expected, epsilon, opt_message) {
+    checkNumber(expected);
+    checkNumber(epsilon);
+    return evaluate(this.subject_, function(actual) {
+      checkNumber(actual);
+      if (Math.abs(expected - actual) > epsilon) {
+        assert.fail(opt_message || `${actual} === ${expected} (± ${epsilon})`);
+      }
+    });
+  }
+
+  /**
+   * @param {function(new: ?)} ctor The exptected type's constructor.
+   * @param {string=} opt_message An optional failure message.
+   * @return {(Promise|undefined)} The result of this assertion, if the subject
+   *     is a promised-value. Otherwise, the assertion is performed immediately
+   *     and nothing is returned.
+   */
+  instanceOf(ctor, opt_message) {
+    checkFunction(ctor);
+    return evaluate(this.subject_, function(actual) {
+      if (!(actual instanceof ctor)) {
+        assert.fail(
+            opt_message
+                || `${describe(actual)} instanceof ${ctor.name || ctor}`);
+      }
+    });
+  }
+
+  /**
+   * @param {string=} opt_message An optional failure message.
+   * @return {(Promise|undefined)} The result of this assertion, if the subject
+   *     is a promised-value. Otherwise, the assertion is performed immediately
+   *     and nothing is returned.
+   */
+  isNull(opt_message) {
+    return this.isEqualTo(null);
+  }
+
+  /**
+   * @param {string=} opt_message An optional failure message.
+   * @return {(Promise|undefined)} The result of this assertion, if the subject
+   *     is a promised-value. Otherwise, the assertion is performed immediately
+   *     and nothing is returned.
+   */
+  isUndefined(opt_message) {
+    return this.isEqualTo(void(0));
+  }
+
+  /**
+   * Ensures the subject of this assertion is either a string or array
+   * containing the given `value`.
+   *
+   * @param {?} value The value expected to be contained within the subject.
+   * @param {string=} opt_message An optional failure message.
+   * @return {(Promise|undefined)} The result of this assertion, if the subject
+   *     is a promised-value. Otherwise, the assertion is performed immediately
+   *     and nothing is returned.
+   */
+  contains(value, opt_message) {
+    return evaluate(this.subject_, function(actual) {
+      if (actual instanceof Map || actual instanceof Set) {
+        assert.ok(actual.has(value), opt_message || `${actual}.has(${value})`);
+      } else if (Array.isArray(actual) || isString(actual)) {
+        assert.ok(
+            actual.indexOf(value) !== -1,
+            opt_message || `${actual}.indexOf(${value}) !== -1`);
+      } else {
+        assert.fail(
+            `Expected an array, map, set, or string: got ${describe(actual)}`);
+      }
+    });
+  }
+
+  /**
+   * @param {string} str The expected suffix.
+   * @param {string=} opt_message An optional failure message.
+   * @return {(Promise|undefined)} The result of this assertion, if the subject
+   *     is a promised-value. Otherwise, the assertion is performed immediately
+   *     and nothing is returned.
+   */
+  endsWith(str, opt_message) {
+    checkString(str);
+    return evaluate(this.subject_, function(actual) {
+      if (!isString(actual) || !actual.endsWith(str)) {
+        assert.fail(actual, str, 'ends with');
+      }
+    });
+  }
+
+  /**
+   * @param {string} str The expected prefix.
+   * @param {string=} opt_message An optional failure message.
+   * @return {(Promise|undefined)} The result of this assertion, if the subject
+   *     is a promised-value. Otherwise, the assertion is performed immediately
+   *     and nothing is returned.
+   */
+  startsWith(str, opt_message) {
+    checkString(str);
+    return evaluate(this.subject_, function(actual) {
+      if (!isString(actual) || !actual.startsWith(str)) {
+        assert.fail(actual, str, 'starts with');
+      }
+    });
+  }
+
+  /**
+   * @param {!RegExp} regex The regex the subject is expected to match.
+   * @param {string=} opt_message An optional failure message.
+   * @return {(Promise|undefined)} The result of this assertion, if the subject
+   *     is a promised-value. Otherwise, the assertion is performed immediately
+   *     and nothing is returned.
+   */
+  matches(regex, opt_message) {
+    if (!(regex instanceof RegExp)) {
+      throw TypeError(`Not a RegExp: ${describe(regex)}`);
+    }
+    return evaluate(this.subject_, function(actual) {
+      if (!isString(actual) || !regex.test(actual)) {
+        let message = opt_message
+            || `Expected a string matching ${regex}, got ${describe(actual)}`;
+        assert.fail(actual, regex, message);
+      }
+    });
+  }
+
+  /**
+   * @param {?} value The unexpected value.
+   * @param {string=} opt_message An optional failure message.
+   * @return {(Promise|undefined)} The result of this assertion, if the subject
+   *     is a promised-value. Otherwise, the assertion is performed immediately
+   *     and nothing is returned.
+   */
+  notEqualTo(value, opt_message) {
+    return evaluate(this.subject_, function(actual) {
+      assert.notStrictEqual(actual, value, opt_message);
+    });
+  }
+
+  /** An alias for {@link #isEqualTo}. */
+  equalTo(value, opt_message) {
+    return this.isEqualTo(value, opt_message);
+  }
+
+  /** An alias for {@link #isEqualTo}. */
+  equals(value, opt_message) {
+    return this.isEqualTo(value, opt_message);
+  }
+
+  /**
+   * @param {?} value The expected value.
+   * @param {string=} opt_message An optional failure message.
+   * @return {(Promise|undefined)} The result of this assertion, if the subject
+   *     is a promised-value. Otherwise, the assertion is performed immediately
+   *     and nothing is returned.
+   */
+  isEqualTo(value, opt_message) {
+    return evaluate(this.subject_, function(actual) {
+      assert.strictEqual(actual, value, opt_message);
+    });
+  }
+
+  /**
+   * @param {string=} opt_message An optional failure message.
+   * @return {(Promise|undefined)} The result of this assertion, if the subject
+   *     is a promised-value. Otherwise, the assertion is performed immediately
+   *     and nothing is returned.
+   */
+  isTrue(opt_message) {
+    return this.isEqualTo(true, opt_message);
+  }
+
+  /**
+   * @param {string=} opt_message An optional failure message.
+   * @return {(Promise|undefined)} The result of this assertion, if the subject
+   *     is a promised-value. Otherwise, the assertion is performed immediately
+   *     and nothing is returned.
+   */
+  isFalse(opt_message) {
+    return this.isEqualTo(false, opt_message);
+  }
+}
+
+
+// PUBLIC API
+
+
+/**
+ * Creates an assertion about the given `value`.
+ * @return {!Assertion} the new assertion.
+ */
+module.exports = function assertThat(value) {
+  return new Assertion(value);
+};
+module.exports.Assertion = Assertion;  // Exported to help generated docs
diff --git a/node_modules/selenium-webdriver/testing/index.js b/node_modules/selenium-webdriver/testing/index.js
new file mode 100644
index 000000000..0e9d06232
--- /dev/null
+++ b/node_modules/selenium-webdriver/testing/index.js
@@ -0,0 +1,277 @@
+// Licensed to the Software Freedom Conservancy (SFC) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The SFC licenses this file
+// to you 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 Provides wrappers around the following global functions from
+ * [Mocha's BDD interface](https://github.com/mochajs/mocha):
+ *
+ * - after
+ * - afterEach
+ * - before
+ * - beforeEach
+ * - it
+ * - it.only
+ * - it.skip
+ * - xit
+ *
+ * The provided wrappers leverage the {@link webdriver.promise.ControlFlow}
+ * to simplify writing asynchronous tests:
+ *
+ *     var By = require('selenium-webdriver').By,
+ *         until = require('selenium-webdriver').until,
+ *         firefox = require('selenium-webdriver/firefox'),
+ *         test = require('selenium-webdriver/testing');
+ *
+ *     test.describe('Google Search', function() {
+ *       var driver;
+ *
+ *       test.before(function() {
+ *         driver = new firefox.Driver();
+ *       });
+ *
+ *       test.after(function() {
+ *         driver.quit();
+ *       });
+ *
+ *       test.it('should append query to title', function() {
+ *         driver.get('http://www.google.com/ncr');
+ *         driver.findElement(By.name('q')).sendKeys('webdriver');
+ *         driver.findElement(By.name('btnG')).click();
+ *         driver.wait(until.titleIs('webdriver - Google Search'), 1000);
+ *       });
+ *     });
+ *
+ * You may conditionally suppress a test function using the exported
+ * "ignore" function. If the provided predicate returns true, the attached
+ * test case will be skipped:
+ *
+ *     test.ignore(maybe()).it('is flaky', function() {
+ *       if (Math.random() < 0.5) throw Error();
+ *     });
+ *
+ *     function maybe() { return Math.random() < 0.5; }
+ */
+
+var promise = require('..').promise;
+var flow = promise.controlFlow();
+
+
+/**
+ * Wraps a function so that all passed arguments are ignored.
+ * @param {!Function} fn The function to wrap.
+ * @return {!Function} The wrapped function.
+ */
+function seal(fn) {
+  return function() {
+    fn();
+  };
+}
+
+
+/**
+ * Wraps a function on Mocha's BDD interface so it runs inside a
+ * webdriver.promise.ControlFlow and waits for the flow to complete before
+ * continuing.
+ * @param {!Function} globalFn The function to wrap.
+ * @return {!Function} The new function.
+ */
+function wrapped(globalFn) {
+  return function() {
+    if (arguments.length === 1) {
+      return globalFn(wrapArgument(arguments[0]));
+
+    } else if (arguments.length === 2) {
+      return globalFn(arguments[0], wrapArgument(arguments[1]));
+
+    } else {
+      throw Error('Invalid # arguments: ' + arguments.length);
+    }
+  };
+}
+
+
+function wrapArgument(value) {
+  if (typeof value === 'function') {
+    return makeAsyncTestFn(value);
+  }
+  return value;
+}
+
+
+/**
+ * Make a wrapper to invoke caller's test function, fn.  Run the test function
+ * within a ControlFlow.
+ *
+ * Should preserve the semantics of Mocha's Runnable.prototype.run (See
+ * https://github.com/mochajs/mocha/blob/master/lib/runnable.js#L192)
+ *
+ * @param {Function} fn
+ * @return {Function}
+ */
+function makeAsyncTestFn(fn) {
+  var async = fn.length > 0; // if test function expects a callback, its "async"
+
+  var ret = /** @type {function(this: mocha.Context)}*/ (function(done) {
+    var runnable = this.runnable();
+    var mochaCallback = runnable.callback;
+    runnable.callback = function() {
+      flow.reset();
+      return mochaCallback.apply(this, arguments);
+    };
+
+    var testFn = fn.bind(this);
+    flow.execute(function controlFlowExecute() {
+      return new promise.Promise(function(fulfill, reject) {
+        if (async) {
+          // If testFn is async (it expects a done callback), resolve the promise of this
+          // test whenever that callback says to.  Any promises returned from testFn are
+          // ignored.
+          testFn(function testFnDoneCallback(err) {
+            if (err) {
+              reject(err);
+            } else {
+              fulfill();
+            }
+          });
+        } else {
+          // Without a callback, testFn can return a promise, or it will
+          // be assumed to have completed synchronously
+          fulfill(testFn());
+        }
+      }, flow);
+    }, runnable.fullTitle()).then(seal(done), done);
+  });
+
+  ret.toString = function() {
+    return fn.toString();
+  };
+
+  return ret;
+}
+
+
+/**
+ * Ignores the test chained to this function if the provided predicate returns
+ * true.
+ * @param {function(): boolean} predicateFn A predicate to call to determine
+ *     if the test should be suppressed. This function MUST be synchronous.
+ * @return {!Object} An object with wrapped versions of {@link #it()} and
+ *     {@link #describe()} that ignore tests as indicated by the predicate.
+ */
+function ignore(predicateFn) {
+  var describe = wrap(exports.xdescribe, exports.describe);
+  describe.only = wrap(exports.xdescribe, exports.describe.only);
+
+  var it = wrap(exports.xit, exports.it);
+  it.only = wrap(exports.xit, exports.it.only);
+
+  return {
+    describe: describe,
+    it: it
+  };
+
+  function wrap(onSkip, onRun) {
+    return function(title, fn) {
+      if (predicateFn()) {
+        onSkip(title, fn);
+      } else {
+        onRun(title, fn);
+      }
+    };
+  }
+}
+
+
+// PUBLIC API
+
+
+/**
+ * @return {!promise.ControlFlow} the control flow instance used by this module
+ *     to coordinate test actions.
+ */
+exports.controlFlow = function(){
+  return flow;
+};
+
+
+/**
+ * Registers a new test suite.
+ * @param {string} name The suite name.
+ * @param {function()=} fn The suite function, or {@code undefined} to define
+ *     a pending test suite.
+ */
+exports.describe = global.describe;
+
+/**
+ * Defines a suppressed test suite.
+ * @param {string} name The suite name.
+ * @param {function()=} fn The suite function, or {@code undefined} to define
+ *     a pending test suite.
+ */
+exports.xdescribe = global.xdescribe;
+exports.describe.skip = global.describe.skip;
+
+/**
+ * Register a function to call after the current suite finishes.
+ * @param {function()} fn .
+ */
+exports.after = wrapped(global.after);
+
+/**
+ * Register a function to call after each test in a suite.
+ * @param {function()} fn .
+ */
+exports.afterEach = wrapped(global.afterEach);
+
+/**
+ * Register a function to call before the current suite starts.
+ * @param {function()} fn .
+ */
+exports.before = wrapped(global.before);
+
+/**
+ * Register a function to call before each test in a suite.
+ * @param {function()} fn .
+ */
+exports.beforeEach = wrapped(global.beforeEach);
+
+/**
+ * Add a test to the current suite.
+ * @param {string} name The test name.
+ * @param {function()=} fn The test function, or {@code undefined} to define
+ *     a pending test case.
+ */
+exports.it = wrapped(global.it);
+
+/**
+ * An alias for {@link #it()} that flags the test as the only one that should
+ * be run within the current suite.
+ * @param {string} name The test name.
+ * @param {function()=} fn The test function, or {@code undefined} to define
+ *     a pending test case.
+ */
+exports.iit = exports.it.only = wrapped(global.it.only);
+
+/**
+ * Adds a test to the current suite while suppressing it so it is not run.
+ * @param {string} name The test name.
+ * @param {function()=} fn The test function, or {@code undefined} to define
+ *     a pending test case.
+ */
+exports.xit = exports.it.skip = wrapped(global.xit);
+
+exports.ignore = ignore;