selenium-webdriver 2.48.2 → 2.52.0

package/lib/goog/testing/functionmock.js

@@ -1,175 +0,0 @@
-// Copyright 2008 The Closure Library Authors. All Rights Reserved.
-//
-// 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 Enable mocking of functions not attached to objects
- * whether they be global / top-level or anonymous methods / closures.
- *
- * See the unit tests for usage.
- *
- */
-
-goog.provide('goog.testing');
-goog.provide('goog.testing.FunctionMock');
-goog.provide('goog.testing.GlobalFunctionMock');
-goog.provide('goog.testing.MethodMock');
-
-goog.require('goog.object');
-goog.require('goog.testing.LooseMock');
-goog.require('goog.testing.Mock');
-goog.require('goog.testing.PropertyReplacer');
-goog.require('goog.testing.StrictMock');
-
-
-/**
- * Class used to mock a function. Useful for mocking closures and anonymous
- * callbacks etc. Creates a function object that extends goog.testing.Mock.
- * @param {string=} opt_functionName The optional name of the function to mock.
- *     Set to '[anonymous mocked function]' if not passed in.
- * @param {number=} opt_strictness One of goog.testing.Mock.LOOSE or
- *     goog.testing.Mock.STRICT. The default is STRICT.
- * @return {!goog.testing.MockInterface} The mocked function.
- * @suppress {missingProperties} Mocks do not fit in the type system well.
- */
-goog.testing.FunctionMock = function(opt_functionName, opt_strictness) {
-  var fn = function() {
-    var args = Array.prototype.slice.call(arguments);
-    args.splice(0, 0, opt_functionName || '[anonymous mocked function]');
-    return fn.$mockMethod.apply(fn, args);
-  };
-  var base = opt_strictness === goog.testing.Mock.LOOSE ?
-      goog.testing.LooseMock : goog.testing.StrictMock;
-  goog.object.extend(fn, new base({}));
-
-  return /** @type {!goog.testing.MockInterface} */ (fn);
-};
-
-
-/**
- * Mocks an existing function. Creates a goog.testing.FunctionMock
- * and registers it in the given scope with the name specified by functionName.
- * @param {Object} scope The scope of the method to be mocked out.
- * @param {string} functionName The name of the function we're going to mock.
- * @param {number=} opt_strictness One of goog.testing.Mock.LOOSE or
- *     goog.testing.Mock.STRICT. The default is STRICT.
- * @return {!goog.testing.MockInterface} The mocked method.
- */
-goog.testing.MethodMock = function(scope, functionName, opt_strictness) {
-  if (!(functionName in scope)) {
-    throw Error(functionName + ' is not a property of the given scope.');
-  }
-
-  var fn = goog.testing.FunctionMock(functionName, opt_strictness);
-
-  fn.$propertyReplacer_ = new goog.testing.PropertyReplacer();
-  fn.$propertyReplacer_.set(scope, functionName, fn);
-  fn.$tearDown = goog.testing.MethodMock.$tearDown;
-
-  return fn;
-};
-
-
-/**
- * Resets the global function that we mocked back to its original state.
- * @this {goog.testing.MockInterface}
- */
-goog.testing.MethodMock.$tearDown = function() {
-  this.$propertyReplacer_.reset();
-};
-
-
-/**
- * Mocks a global / top-level function. Creates a goog.testing.MethodMock
- * in the global scope with the name specified by functionName.
- * @param {string} functionName The name of the function we're going to mock.
- * @param {number=} opt_strictness One of goog.testing.Mock.LOOSE or
- *     goog.testing.Mock.STRICT. The default is STRICT.
- * @return {!goog.testing.MockInterface} The mocked global function.
- */
-goog.testing.GlobalFunctionMock = function(functionName, opt_strictness) {
-  return goog.testing.MethodMock(goog.global, functionName, opt_strictness);
-};
-
-
-/**
- * Convenience method for creating a mock for a function.
- * @param {string=} opt_functionName The optional name of the function to mock
- *     set to '[anonymous mocked function]' if not passed in.
- * @param {number=} opt_strictness One of goog.testing.Mock.LOOSE or
- *     goog.testing.Mock.STRICT. The default is STRICT.
- * @return {!goog.testing.MockInterface} The mocked function.
- */
-goog.testing.createFunctionMock = function(opt_functionName, opt_strictness) {
-  return goog.testing.FunctionMock(opt_functionName, opt_strictness);
-};
-
-
-/**
- * Convenience method for creating a mock for a method.
- * @param {Object} scope The scope of the method to be mocked out.
- * @param {string} functionName The name of the function we're going to mock.
- * @param {number=} opt_strictness One of goog.testing.Mock.LOOSE or
- *     goog.testing.Mock.STRICT. The default is STRICT.
- * @return {!goog.testing.MockInterface} The mocked global function.
- */
-goog.testing.createMethodMock = function(scope, functionName, opt_strictness) {
-  return goog.testing.MethodMock(scope, functionName, opt_strictness);
-};
-
-
-/**
- * Convenience method for creating a mock for a constructor. Copies class
- * members to the mock.
- *
- * <p>When mocking a constructor to return a mocked instance, remember to create
- * the instance mock before mocking the constructor. If you mock the constructor
- * first, then the mock framework will be unable to examine the prototype chain
- * when creating the mock instance.
- * @param {Object} scope The scope of the constructor to be mocked out.
- * @param {string} constructorName The name of the constructor we're going to
- *     mock.
- * @param {number=} opt_strictness One of goog.testing.Mock.LOOSE or
- *     goog.testing.Mock.STRICT. The default is STRICT.
- * @return {!goog.testing.MockInterface} The mocked constructor.
- */
-goog.testing.createConstructorMock = function(scope, constructorName,
-                                              opt_strictness) {
-  var realConstructor = scope[constructorName];
-  var constructorMock = goog.testing.MethodMock(scope, constructorName,
-                                                opt_strictness);
-
-  // Copy class members from the real constructor to the mock. Do not copy
-  // the closure superClass_ property (see goog.inherits), the built-in
-  // prototype property, or properties added to Function.prototype
-  for (var property in realConstructor) {
-    if (property != 'superClass_' &&
-        property != 'prototype' &&
-        realConstructor.hasOwnProperty(property)) {
-      constructorMock[property] = realConstructor[property];
-    }
-  }
-  return constructorMock;
-};
-
-
-/**
- * Convenience method for creating a mocks for a global / top-level function.
- * @param {string} functionName The name of the function we're going to mock.
- * @param {number=} opt_strictness One of goog.testing.Mock.LOOSE or
- *     goog.testing.Mock.STRICT. The default is STRICT.
- * @return {!goog.testing.MockInterface} The mocked global function.
- */
-goog.testing.createGlobalFunctionMock = function(functionName, opt_strictness) {
-  return goog.testing.GlobalFunctionMock(functionName, opt_strictness);
-};

package/lib/goog/testing/jsunit.js

@@ -1,162 +0,0 @@
-// Copyright 2007 The Closure Library Authors. All Rights Reserved.
-//
-// 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 Utilities for working with JsUnit.  Writes out the JsUnit file
- * that needs to be included in every unit test.
- *
- * Testing code should not have dependencies outside of goog.testing so as to
- * reduce the chance of masking missing dependencies.
- *
- */
-
-goog.provide('goog.testing.jsunit');
-
-goog.require('goog.dom.TagName');
-goog.require('goog.testing.TestCase');
-goog.require('goog.testing.TestRunner');
-
-
-/**
- * Base path for JsUnit app files, relative to Closure's base path.
- * @type {string}
- */
-goog.testing.jsunit.BASE_PATH =
-    '../../third_party/java/jsunit/core/app/';
-
-
-/**
- * Filename for the core JS Unit script.
- * @type {string}
- */
-goog.testing.jsunit.CORE_SCRIPT =
-    goog.testing.jsunit.BASE_PATH + 'jsUnitCore.js';
-
-
-/**
- * @define {boolean} If this code is being parsed by JsTestC, we let it disable
- * the onload handler to avoid running the test in JsTestC.
- */
-goog.define('goog.testing.jsunit.AUTO_RUN_ONLOAD', true);
-
-
-/**
- * @define {number} Sets a delay in milliseconds after the window onload event
- * and running the tests. Used to prevent interference with Selenium and give
- * tests with asynchronous operations time to finish loading.
- */
-goog.define('goog.testing.jsunit.AUTO_RUN_DELAY_IN_MS', 500);
-
-
-(function() {
-  // Only allow one global test runner to be created on a page.
-  if (goog.global['G_testRunner'] instanceof goog.testing.TestRunner) {
-    return;
-  }
-
-  // Increases the maximum number of stack frames in Google Chrome from the
-  // default 10 to 50 to get more useful stack traces.
-  Error.stackTraceLimit = 50;
-
-  // Store a reference to the window's timeout so that it can't be overridden
-  // by tests.
-  /** @type {!Function} */
-  var realTimeout = window.setTimeout;
-
-  // Check for JsUnit's test runner (need to check for >2.2 and <=2.2)
-  if (top['JsUnitTestManager'] || top['jsUnitTestManager']) {
-    // Running inside JsUnit so add support code.
-    var path = goog.basePath + goog.testing.jsunit.CORE_SCRIPT;
-    document.write('<script type="text/javascript" src="' +
-                   path + '"></' + 'script>');
-
-  } else {
-
-    // Create a test runner.
-    var tr = new goog.testing.TestRunner();
-
-    // Export it so that it can be queried by Selenium and tests that use a
-    // compiled test runner.
-    goog.exportSymbol('G_testRunner', tr);
-    goog.exportSymbol('G_testRunner.initialize', tr.initialize);
-    goog.exportSymbol('G_testRunner.isInitialized', tr.isInitialized);
-    goog.exportSymbol('G_testRunner.isFinished', tr.isFinished);
-    goog.exportSymbol('G_testRunner.isSuccess', tr.isSuccess);
-    goog.exportSymbol('G_testRunner.getReport', tr.getReport);
-    goog.exportSymbol('G_testRunner.getRunTime', tr.getRunTime);
-    goog.exportSymbol('G_testRunner.getNumFilesLoaded', tr.getNumFilesLoaded);
-    goog.exportSymbol('G_testRunner.setStrict', tr.setStrict);
-    goog.exportSymbol('G_testRunner.logTestFailure', tr.logTestFailure);
-    goog.exportSymbol('G_testRunner.getTestResults', tr.getTestResults);
-
-    // Export debug as a global function for JSUnit compatibility.  This just
-    // calls log on the current test case.
-    if (!goog.global['debug']) {
-      goog.exportSymbol('debug', goog.bind(tr.log, tr));
-    }
-
-    // If the application has defined a global error filter, set it now.  This
-    // allows users who use a base test include to set the error filter before
-    // the testing code is loaded.
-    if (goog.global['G_errorFilter']) {
-      tr.setErrorFilter(goog.global['G_errorFilter']);
-    }
-
-    // Add an error handler to report errors that may occur during
-    // initialization of the page.
-    var onerror = window.onerror;
-    window.onerror = function(error, url, line) {
-      // Call any existing onerror handlers.
-      if (onerror) {
-        onerror(error, url, line);
-      }
-      if (typeof error == 'object') {
-        // Webkit started passing an event object as the only argument to
-        // window.onerror.  It doesn't contain an error message, url or line
-        // number.  We therefore log as much info as we can.
-        if (error.target && error.target.tagName == goog.dom.TagName.SCRIPT) {
-          tr.logError('UNKNOWN ERROR: Script ' + error.target.src);
-        } else {
-          tr.logError('UNKNOWN ERROR: No error information available.');
-        }
-      } else {
-        tr.logError('JS ERROR: ' + error + '\nURL: ' + url + '\nLine: ' + line);
-      }
-    };
-
-    // Create an onload handler, if the test runner hasn't been initialized then
-    // no test has been registered with the test runner by the test file.  We
-    // then create a new test case and auto discover any tests in the global
-    // scope. If this code is being parsed by JsTestC, we let it disable the
-    // onload handler to avoid running the test in JsTestC.
-    if (goog.testing.jsunit.AUTO_RUN_ONLOAD) {
-      var onload = window.onload;
-      window.onload = function(e) {
-        // Call any existing onload handlers.
-        if (onload) {
-          onload(e);
-        }
-        // Wait so that we don't interfere with WebDriver.
-        realTimeout(function() {
-          if (!tr.initialized) {
-            var testCase = new goog.testing.TestCase(document.title);
-            goog.testing.TestCase.initializeTestRunner(testCase);
-          }
-          tr.execute();
-        }, goog.testing.jsunit.AUTO_RUN_DELAY_IN_MS);
-        window.onload = null;
-      };
-    }
-  }
-})();

package/lib/goog/testing/loosemock.js

@@ -1,242 +0,0 @@
-// Copyright 2008 The Closure Library Authors. All Rights Reserved.
-//
-// 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 This file defines a loose mock implementation.
- */
-
-goog.provide('goog.testing.LooseExpectationCollection');
-goog.provide('goog.testing.LooseMock');
-
-goog.require('goog.array');
-goog.require('goog.structs.Map');
-goog.require('goog.testing.Mock');
-
-
-
-/**
- * This class is an ordered collection of expectations for one method. Since
- * the loose mock does most of its verification at the time of $verify, this
- * class is necessary to manage the return/throw behavior when the mock is
- * being called.
- * @constructor
- * @final
- */
-goog.testing.LooseExpectationCollection = function() {
-  /**
-   * The list of expectations. All of these should have the same name.
-   * @type {Array<goog.testing.MockExpectation>}
-   * @private
-   */
-  this.expectations_ = [];
-};
-
-
-/**
- * Adds an expectation to this collection.
- * @param {goog.testing.MockExpectation} expectation The expectation to add.
- */
-goog.testing.LooseExpectationCollection.prototype.addExpectation =
-    function(expectation) {
-  this.expectations_.push(expectation);
-};
-
-
-/**
- * Gets the list of expectations in this collection.
- * @return {Array<goog.testing.MockExpectation>} The array of expectations.
- */
-goog.testing.LooseExpectationCollection.prototype.getExpectations = function() {
-  return this.expectations_;
-};
-
-
-
-/**
- * This is a mock that does not care about the order of method calls. As a
- * result, it won't throw exceptions until verify() is called. The only
- * exception is that if a method is called that has no expectations, then an
- * exception will be thrown.
- * @param {Object|Function} objectToMock The object that should be mocked, or
- *    the constructor of an object to mock.
- * @param {boolean=} opt_ignoreUnexpectedCalls Whether to ignore unexpected
- *     calls.
- * @param {boolean=} opt_mockStaticMethods An optional argument denoting that
- *     a mock should be constructed from the static functions of a class.
- * @param {boolean=} opt_createProxy An optional argument denoting that
- *     a proxy for the target mock should be created.
- * @constructor
- * @extends {goog.testing.Mock}
- */
-goog.testing.LooseMock = function(objectToMock, opt_ignoreUnexpectedCalls,
-    opt_mockStaticMethods, opt_createProxy) {
-  goog.testing.Mock.call(this, objectToMock, opt_mockStaticMethods,
-      opt_createProxy);
-
-  /**
-   * A map of method names to a LooseExpectationCollection for that method.
-   * @type {goog.structs.Map}
-   * @private
-   */
-  this.$expectations_ = new goog.structs.Map();
-
-  /**
-   * The calls that have been made; we cache them to verify at the end. Each
-   * element is an array where the first element is the name, and the second
-   * element is the arguments.
-   * @type {Array<Array<*>>}
-   * @private
-   */
-  this.$calls_ = [];
-
-  /**
-   * Whether to ignore unexpected calls.
-   * @type {boolean}
-   * @private
-   */
-  this.$ignoreUnexpectedCalls_ = !!opt_ignoreUnexpectedCalls;
-};
-goog.inherits(goog.testing.LooseMock, goog.testing.Mock);
-
-
-/**
- * A setter for the ignoreUnexpectedCalls field.
- * @param {boolean} ignoreUnexpectedCalls Whether to ignore unexpected calls.
- * @return {!goog.testing.LooseMock} This mock object.
- */
-goog.testing.LooseMock.prototype.$setIgnoreUnexpectedCalls = function(
-    ignoreUnexpectedCalls) {
-  this.$ignoreUnexpectedCalls_ = ignoreUnexpectedCalls;
-  return this;
-};
-
-
-/** @override */
-goog.testing.LooseMock.prototype.$recordExpectation = function() {
-  if (!this.$expectations_.containsKey(this.$pendingExpectation.name)) {
-    this.$expectations_.set(this.$pendingExpectation.name,
-        new goog.testing.LooseExpectationCollection());
-  }
-
-  var collection = this.$expectations_.get(this.$pendingExpectation.name);
-  collection.addExpectation(this.$pendingExpectation);
-};
-
-
-/** @override */
-goog.testing.LooseMock.prototype.$recordCall = function(name, args) {
-  if (!this.$expectations_.containsKey(name)) {
-    if (this.$ignoreUnexpectedCalls_) {
-      return;
-    }
-    this.$throwCallException(name, args);
-  }
-
-  // Start from the beginning of the expectations for this name,
-  // and iterate over them until we find an expectation that matches
-  // and also has calls remaining.
-  var collection = this.$expectations_.get(name);
-  var matchingExpectation = null;
-  var expectations = collection.getExpectations();
-  for (var i = 0; i < expectations.length; i++) {
-    var expectation = expectations[i];
-    if (this.$verifyCall(expectation, name, args)) {
-      matchingExpectation = expectation;
-      if (expectation.actualCalls < expectation.maxCalls) {
-        break;
-      } // else continue and see if we can find something that does match
-    }
-  }
-  if (matchingExpectation == null) {
-    this.$throwCallException(name, args, expectation);
-  }
-
-  matchingExpectation.actualCalls++;
-  if (matchingExpectation.actualCalls > matchingExpectation.maxCalls) {
-    this.$throwException('Too many calls to ' + matchingExpectation.name +
-            '\nExpected: ' + matchingExpectation.maxCalls + ' but was: ' +
-            matchingExpectation.actualCalls);
-  }
-
-  this.$calls_.push([name, args]);
-  return this.$do(matchingExpectation, args);
-};
-
-
-/** @override */
-goog.testing.LooseMock.prototype.$reset = function() {
-  goog.testing.LooseMock.superClass_.$reset.call(this);
-
-  this.$expectations_ = new goog.structs.Map();
-  this.$calls_ = [];
-};
-
-
-/** @override */
-goog.testing.LooseMock.prototype.$replay = function() {
-  goog.testing.LooseMock.superClass_.$replay.call(this);
-
-  // Verify that there are no expectations that can never be reached.
-  // This can't catch every situation, but it is a decent sanity check
-  // and it's similar to the behavior of EasyMock in java.
-  var collections = this.$expectations_.getValues();
-  for (var i = 0; i < collections.length; i++) {
-    var expectations = collections[i].getExpectations();
-    for (var j = 0; j < expectations.length; j++) {
-      var expectation = expectations[j];
-      // If this expectation can be called infinite times, then
-      // check if any subsequent expectation has the exact same
-      // argument list.
-      if (!isFinite(expectation.maxCalls)) {
-        for (var k = j + 1; k < expectations.length; k++) {
-          var laterExpectation = expectations[k];
-          if (laterExpectation.minCalls > 0 &&
-              goog.array.equals(expectation.argumentList,
-                  laterExpectation.argumentList)) {
-            var name = expectation.name;
-            var argsString = this.$argumentsAsString(expectation.argumentList);
-            this.$throwException([
-              'Expected call to ', name, ' with arguments ', argsString,
-              ' has an infinite max number of calls; can\'t expect an',
-              ' identical call later with a positive min number of calls'
-            ].join(''));
-          }
-        }
-      }
-    }
-  }
-};
-
-
-/** @override */
-goog.testing.LooseMock.prototype.$verify = function() {
-  goog.testing.LooseMock.superClass_.$verify.call(this);
-  var collections = this.$expectations_.getValues();
-
-  for (var i = 0; i < collections.length; i++) {
-    var expectations = collections[i].getExpectations();
-    for (var j = 0; j < expectations.length; j++) {
-      var expectation = expectations[j];
-      if (expectation.actualCalls > expectation.maxCalls) {
-        this.$throwException('Too many calls to ' + expectation.name +
-            '\nExpected: ' + expectation.maxCalls + ' but was: ' +
-            expectation.actualCalls);
-      } else if (expectation.actualCalls < expectation.minCalls) {
-        this.$throwException('Not enough calls to ' + expectation.name +
-            '\nExpected: ' + expectation.minCalls + ' but was: ' +
-            expectation.actualCalls);
-      }
-    }
-  }
-};