Added guts to pull call signatures when assertions & expectations fail.

chrome/test/data/webui/test_api.js

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 /**
  * @fileoverview Library providing basic test framework functionality.
  **/
 
 /**
  * Namespace for |Test|.
@@ skipping 56 matching lines @@
 
     /**
      * When set to a function, will be called in the context of the test
      * generation inside the function, and before any generated C++.
      * @type {function(string,string)}
      **/
     testGenPreamble: null,
 
     /**
      * When set to a function, will be called in the context of the test
-     * generation inside the function, and before any generated C++.
+     * generation inside the function, and after any generated C++.
      * @type {function(string,string)}
      **/
     testGenPostamble: null,
 
     /**
      * When set to a non-null String, auto-generate typedef before generating
      * TEST*: {@code typedef typedefCppFixture testFixture}.
      * @type {String}
      **/
     typedefCppFixture: 'WebUIBrowserTest',
@@ skipping 51 matching lines @@
     /**
      * Called at preload time, proxies to the fixture.
      * @type {Function}
      **/
     PreLoad: function(name) {
       if (this.fixture)
         this.fixture.PreLoad();
     },
 
     /**
-     * Runs this test case.
+     * Runs this test case with |this| set to the |fixture|.
+     *
+     * Note: Tests created with TEST_F may depend upon |this| being set to an
+     * instance of this.fixture. The current implementation of TEST creates a
+     * dummy constructor, but tests created with TEST should not rely on |this|
+     * being set.
      * @type {Function}
      **/
     Run: function() {
       if (this.fixture)
         this.fixture.SetUp();
       if (this.body)
         this.body.call(this.fixture);
       if (this.fixture)
         this.fixture.TearDown();
     },
@@ skipping 50 matching lines @@
    **/
   function send(messageName) {
     var callback = sendCallbacks[messageName];
     var args = Array.prototype.slice.call(arguments, 1);
     if (callback != undefined)
       callback[1].apply(callback[0], args);
     else
       oldChrome.send.apply(oldChrome, args);
   }
 
+  /**
+   * Provides a mechanism for assert* and expect* methods to fetch the signature
+   * of their caller. Assert* methods should |registerCall| and expect* methods
+   * should set |isExpect| and |expectName| properties to indicate that the
+   * interesting caller is one more level up the stack.
+   **/
+  function CallHelper() {
+    this.__proto__ = CallHelper.prototype;
+  }
+
+  CallHelper.prototype = {
+    /**
+     * Holds the mapping of (callerCallerString, callerName) -> count of times
+     * called.
+     * @type {Object.<string, Object.<string, number>>}
+     **/
+    'counts_': {},
+
+    /**
+     * This information about the caller is needed from most of the following
+     * routines.
+     * @param {Function} caller the caller of the assert* routine.
+     * @return {{callerName: string, callercallerString: string}} stackInfo
+     **/
+    'getCallerInfo': function(caller) {
+      var callerName = caller.name;
+      var callerCaller = caller.caller;
+      if (callerCaller['isExpect']) {
+        callerName = callerCaller.expectName;
+        callerCaller = callerCaller.caller;
+      }
+      var callerCallerString = callerCaller.toString();
+      return {
+        callerName: callerName,
+        callerCallerString: callerCallerString,
+      };
+    },
+
+    /**
+     * Register a call to an assertion class.
+     **/
+    'registerCall': function() {
+      var stackInfo = this.getCallerInfo(arguments.callee.caller);
+      if (!(stackInfo.callerCallerString in this.counts_))
+        this.counts_[stackInfo.callerCallerString] = {};
+      if (!(stackInfo.callerName in this.counts_[stackInfo.callerCallerString]))
+        this.counts_[stackInfo.callerCallerString][stackInfo.callerName] = 0;
+      ++this.counts_[stackInfo.callerCallerString][stackInfo.callerName];
+    },
+
+    /**
+     * @param {String} string the string to match parentheses.
+     * @param {number} index offset to the opening parenthesis.
+     * @return {[number, Array]} the index after matching paren and the args.
+     **/
+    'matchedParamsIndex': function(string, index) {
+      var args = [];
+      var parenCount = 1;
+      var argStart = index + 1;
+      for(index = argStart;
+          parenCount && index < string.length;
+          ++index) {
+        if (string[index] == '(') {
+          ++parenCount;
+        } else if (string[index] == ')') {
+          if (--parenCount == 0)
+            args.push(string.substring(argStart, index));
+        } else if (string[index] == ',' && parenCount == 1) {
+          args.push(string.substring(argStart, index));
+          argStart = index + 1;
+        }
+      }
+      return [index, args];
+    },
+
+    /**
+     * Get the parameters of this instance of caller's call to this function.
+     * @param {Function} caller_ a particular caller or |undefined|.
+     * @param {number} count_ the number of times this instance was called.
+     * @return {Array.<string>} parameters of caller's call to this function.
+     **/
+    'getParams': function(caller_, count_) {
+      var caller = (caller_ == undefined) ?
+          arguments.callee.caller : caller_;
+      var stackInfo = this.getCallerInfo(caller);
+      var count = (count_ == undefined) ?
+          this.counts_[stackInfo.callerCallerString][stackInfo.callerName] :
+          count_;
+      var searchStart = 0;
+      var args;
+      for(var i = 0;
+          i < count && searchStart < stackInfo.callerCallerString.length;
+          ++i) {
+        searchStart = stackInfo.callerCallerString.indexOf(
+            stackInfo.callerName, searchStart);
+        if (searchStart == -1) {
+          if (i && count_ == undefined) {
+            return this.getParams(caller, ((count - 1) % i) + 1);
+          } else {
+            console.error('bad count ' + count);
+            return undefined;
+          }
+        }
+        searchStart += stackInfo.callerName.length;
+        var matched = this.matchedParamsIndex(stackInfo.callerCallerString,
+                                              searchStart);
+        args = matched[1];
+        searchStart = matched[0];
+      }
+      return args;
+    },
+
+    /**
+     * Get the call signature of this instance of the caller's call to this
+     * function.
+     * @return {String} call signature.
+     **/
+    'getCall': function() {
+      var caller = arguments.callee.caller;
+      var stackInfo = this.getCallerInfo(caller);
+      return stackInfo.callerName + '(' + this.getParams(caller) + ')';
+    },
+  };
+
+  /**
+   * Help register calls for better error reporting.
+   * @type {CallHelper}
+   **/
+  var helper = new CallHelper();
+
   // Asserts.
   // Use the following assertions to verify a condition within a test.
   // If assertion fails, the C++ backend will be immediately notified.
   // If assertion passes, no notification will be sent to the C++ backend.
 
   /**
    * When |test| !== |expected|, aborts the current test.
    * @param {Boolean} test The predicate to check against |expected|.
    * @param {Boolean} expected The expected value of |test|.
    * @param {String=} message The message to include in the Error thrown.
    * @throws {Error} upon failure.
    **/
   function assertBool(test, expected, message) {
-    if (test !== expected) {
-      if (message)
-        message = test + '\n' + message;
-      else
-        message = test;
-      throw new Error(message);
-    }
+    helper.registerCall();
+    if (test !== expected)
+      throw new Error('Test Error ' + helper.getCall() + ': ' + test);
   }
 
   /**
    * When |test| !== true, aborts the current test.
    * @param {Boolean} test The predicate to check against |expected|.
    * @param {String=} message The message to include in the Error thrown.
    * @throws {Error} upon failure.
    **/
   function assertTrue(test, message) {
-    assertBool(test, true, message);
+    helper.registerCall();
+    if (test !== true)
+      throw new Error('Test Error ' + helper.getCall() + ': ' + test);
   }
 
   /**
    * When |test| !== false, aborts the current test.
    * @param {Boolean} test The predicate to check against |expected|.
    * @param {String=} message The message to include in the Error thrown.
    * @throws {Error} upon failure.
    **/
   function assertFalse(test, message) {
-    assertBool(test, false, message);
+    helper.registerCall();
+    if (test !== false)
+      throw new Error('Test Error ' + helper.getCall() + ': ' + test);
   }
 
   /**
    * When |expected| !== |actual|, aborts the current test.
    * @param {*} expected The predicate to check against |expected|.
    * @param {*} actual The expected value of |test|.
    * @param {String=} message The message to include in the Error thrown.
    * @throws {Error} upon failure.
    **/
   function assertEquals(expected, actual, message) {
+    helper.registerCall();
     if (expected != actual) {
-      throw new Error('Test Error. Actual: ' + actual + '\nExpected: ' +
-                       expected + '\n' + message);
+      throw new Error('Test Error ' + helper.getCall() + '\nActual: ' + actual +
+                      '\nExpected: ' + expected);
     }
     if (typeof expected != typeof actual) {
-      throw new Error('Test Error' +
-                      ' (type mismatch)\nActual Type: ' + typeof actual +
-                      '\nExpected Type:' + typeof expected + '\n' + message);
+      throw new Error('Test Error (type mismatch) ' + helper.getCall() +
+                      '\nActual Type: ' + typeof actual +
+                      '\nExpected Type:' + typeof expected);
     }
   }
 
   /**
    * Always aborts the current test.
    * @param {String=} message The message to include in the Error thrown.
    * @throws {Error} always.
    **/
   function assertNotReached(message) {
-    throw new Error(message);
+    helper.registerCall();
+    throw new Error(helper.getCall());
   }
 
   /**
    * Holds the errors, if any, caught by expects so that the test case can fail.
    * @type {Array.<Error>}
    **/
   var errors = [];
 
   /**
    * Creates a function based upon a function that thows an exception on
    * failure. The new function stuffs any errors into the |errors| array for
    * checking by runTest. This allows tests to continue running other checks,
    * while failing the overal test if any errors occurrred.
    * @param {Function} assertFunc The function which may throw an Error.
    * @return {Function} A function that applies its arguments to |assertFunc|.
    * @see errors
    * @see runTest
    **/
   function createExpect(assertFunc) {
-    return function() {
+    var expectFunc = function() {
       try {
         assertFunc.apply(null, arguments);
       } catch (e) {
         errors.push(e);
       }
     };
+    expectFunc.isExpect = true;
+    expectFunc.expectName = assertFunc.name.replace(/^assert/, 'expect');
+    return expectFunc;
   }
 
   /**
    * This is the starting point for tests run by WebUIBrowserTest. It clears
    * |errors|, runs the test surrounded by an expect to catch Errors. If
    * |errors| is non-empty, it reports a failure and a message by joining
    * |errors|.
    * @param {String} testFunction The function name to call.
    * @param {Array} testArguments The arguments to call |testFunction| with.
    * @return {Array.<Boolean, String>} [test-succeeded, message-if-failed]
    * @see errors
    * @see createExpect
    **/
   function runTest(testFunction, testArguments) {
-    errors = [];
+    errors.splice(0, errors.length);
     // Avoid eval() if at all possible, since it will not work on pages
     // that have enabled content-security-policy.
     var testBody = this[testFunction];    // global object -- not a method.
     if (typeof testBody === "undefined")
       testBody = eval(testFunction);
-    if (testBody != RUN_TEST_F)
-      console.log('Running test ' + testBody.name);
+    if (testBody != RUN_TEST_F) {
+      var testName =
+          testFunction.name ? testFunction.name : testBody.toString();
+      console.log('Running test ' + testName);
+    }
     createExpect(testBody).apply(null, testArguments);
 
+    var result = [true];
     if (errors.length) {
+      var message = '';
       for (var i = 0; i < errors.length; ++i) {
-        console.log('Failed: ' + testFunction + '(' +
-                    testArguments.toString() + ')\n' + errors[i].stack);
+        message += 'Failed: ' + testFunction + '(' +
+                   testArguments.map(JSON.stringify) +
+                   ')\n' + errors[i].stack;
       }
-      return [false, errors.join('\n')];
-    } else {
-      return [true];
+      errors.splice(0, errors.length);
+      result = [false, message];
     }
+    return result;
   }
 
   /**
    * Creates a new test case for the given |testFixture| and |testName|. Assumes
    * |testFixture| describes a globally available subclass of type Test.
    * @param {String} testFixture The fixture for this test case.
    * @param {String} testName The name for this test case.
    * @return {TestCase} A newly created TestCase.
    **/
   function createTestCase(testFixture, testName) {
@@ skipping 134 matching lines @@
   window.registerMockMessageCallbacks = registerMockMessageCallbacks;
   window.runTest = runTest;
   window.preloadJavascriptLibraries = preloadJavascriptLibraries;
   window.TEST = TEST;
   window.TEST_F = TEST_F;
   window.GEN = GEN;
 
   // Import the Mock4JS helpers.
   Mock4JS.addMockSupport(window);
 })();