--- /dev/null
+// 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);
+ }
+ }
+ }
+};