closure 1.1.692

data/closure-library/closure/goog/testing/testcase.js

@@ -0,0 +1,1053 @@
+// 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 A class representing a set of test functions to be run.
+ *
+ * Testing code should not have dependencies outside of goog.testing so as to
+ * reduce the chance of masking missing dependencies.
+ *
+ * This file does not compile correctly with --collapse_properties. Use
+ * --property_renaming=ALL_UNQUOTED instead.
+ *
+ */
+
+goog.provide('goog.testing.TestCase');
+goog.provide('goog.testing.TestCase.Error');
+goog.provide('goog.testing.TestCase.Order');
+goog.provide('goog.testing.TestCase.Result');
+goog.provide('goog.testing.TestCase.Test');
+
+goog.require('goog.testing.asserts');
+goog.require('goog.testing.stacktrace');
+
+
+
+/**
+ * A class representing a JsUnit test case.  A TestCase is made up of a number
+ * of test functions which can be run.  Individual test cases can override the
+ * following functions to set up their test environment:
+ *   - runTests - completely override the test's runner
+ *   - setUpPage - called before any of the test functions are run
+ *   - tearDownPage - called after all tests are finished
+ *   - setUp - called before each of the test functions
+ *   - tearDown - called after each of the test functions
+ *   - shouldRunTests - called before a test run, all tests are skipped if it
+ *                      returns false.  Can be used to disable tests on browsers
+ *                      where they aren't expected to pass.
+ *
+ * Use {@link #autoDiscoverTests}
+ *
+ * @param {string=} opt_name The name of the test case, defaults to
+ *     'Untitled Test Case'.
+ * @constructor
+ */
+goog.testing.TestCase = function(opt_name) {
+  /**
+   * A name for the test case.
+   * @type {string}
+   * @private
+   */
+  this.name_ = opt_name || 'Untitled Test Case';
+
+  /**
+   * Array of test functions that can be executed.
+   * @type {Array.<goog.testing.TestCase.Test>}
+   * @private
+   */
+  this.tests_ = [];
+
+  /**
+   * Set of test names and/or indices to execute, or null if all tests should
+   * be executed.
+   *
+   * Indices are included to allow automation tools to run a subset of the
+   * tests without knowing the exact contents of the test file.
+   *
+   * Indices should only be used with SORTED ordering.
+   *
+   * Example valid values:
+   * <ul>
+   * <li>[testName]
+   * <li>[testName1, testName2]
+   * <li>[2] - will run the 3rd test in the order specified
+   * <li>[1,3,5]
+   * <li>[testName1, testName2, 3, 5] - will work
+   * <ul>
+   * @type {Object}
+   * @private
+   */
+  this.testsToRun_ = null;
+
+  var search = window.location.search;
+
+  // Parse the 'runTests' query parameter into a set of test names and/or
+  // test indices.
+  var runTestsMatch = search.match(/(?:\?|&)runTests=([^?&]+)/i);
+  if (runTestsMatch) {
+    this.testsToRun_ = {};
+    var arr = runTestsMatch[1].split(',');
+    for (var i = 0, len = arr.length; i < len; i++) {
+      this.testsToRun_[arr[i]] = 1;
+    }
+  }
+
+  // Checks the URL for a valid order param.
+  var orderMatch = search.match(/(?:\?|&)order=(natural|random|sorted)/i);
+  if (orderMatch) {
+    this.order = orderMatch[1];
+  }
+
+  /**
+   * Object used to encapsulate the test results.
+   * @type {goog.testing.TestCase.Result}
+   * @protected
+   * @suppress {underscore}
+   */
+  this.result_ = new goog.testing.TestCase.Result(this);
+
+  // This silences a compiler warning from the legacy property check, which
+  // is deprecated. It idly writes to testRunner properties that are used
+  // in this file.
+  var testRunnerMethods = {isFinished: true, hasErrors: true};
+};
+
+
+/**
+ * The order to run the auto-discovered tests.
+ * @enum {string}
+ */
+goog.testing.TestCase.Order = {
+  /**
+   * This is browser dependent and known to be different in FF and Safari
+   * compared to others.
+   */
+  NATURAL: 'natural',
+
+  /** Random order. */
+  RANDOM: 'random',
+
+  /** Sorted based on the name. */
+  SORTED: 'sorted'
+};
+
+
+/**
+ * The maximum amount of time that the test can run before we force it to be
+ * async.  This prevents the test runner from blocking the browser and
+ * potentially hurting the Selenium test harness.
+ * @type {number}
+ */
+goog.testing.TestCase.MAX_RUN_TIME = 200;
+
+
+/**
+ * The order to run the auto-discovered tests in.
+ * @type {string}
+ */
+goog.testing.TestCase.prototype.order = goog.testing.TestCase.Order.SORTED;
+
+
+/**
+ * Save a reference to window.timeout, so any code that overrides the default
+ * behavior (e.g. MockClock) doesn't affect our runner.
+ * @type {function(this:Window, (Function|string), number, *=): number}
+ * @private
+ */
+goog.testing.TestCase.protectedTimeout_ = window.setTimeout;
+
+
+/**
+ * Saved string referencing window.setTimeout's string serialization.  IE
+ * sometimes fails to uphold equality for setTimeout, but the string version
+ * stays the same.
+ * @type {string}
+ * @private
+ */
+goog.testing.TestCase.setTimeoutAsString_ = String(window.setTimeout);
+
+
+/**
+ * TODO(user) replace this with prototype.currentTest.
+ * Name of the current test that is running, or null if none is running.
+ * @type {?string}
+ */
+goog.testing.TestCase.currentTestName = null;
+
+
+/**
+ * Avoid a dependency on goog.userAgent and keep our own reference of whether
+ * the browser is IE.
+ * @type {boolean}
+ */
+goog.testing.TestCase.IS_IE = typeof opera == 'undefined' && !!navigator &&
+    navigator.userAgent.indexOf('MSIE') != -1;
+
+
+/**
+ * Whether the test case has ever tried to execute.
+ * @type {boolean}
+ */
+goog.testing.TestCase.prototype.started = false;
+
+
+/**
+ * Whether the test case is running.
+ * @type {boolean}
+ */
+goog.testing.TestCase.prototype.running = false;
+
+
+/**
+ * Timestamp for when the test was started.
+ * @type {number}
+ * @private
+ */
+goog.testing.TestCase.prototype.startTime_ = 0;
+
+
+/**
+ * Time since the last batch of tests was started, if batchTime exceeds
+ * {@link #MAX_RUN_TIME} a timeout will be used to stop the tests blocking the
+ * browser and a new batch will be started.
+ * @type {number}
+ * @private
+ */
+goog.testing.TestCase.prototype.batchTime_ = 0;
+
+
+/**
+ * Pointer to the current test.
+ * @type {number}
+ * @private
+ */
+goog.testing.TestCase.prototype.currentTestPointer_ = 0;
+
+
+/**
+ * Optional callback that will be executed when the test has finalized.
+ * @type {Function}
+ * @private
+ */
+goog.testing.TestCase.prototype.onCompleteCallback_ = null;
+
+
+/**
+ * The test runner that is running this case.
+ * @type {goog.testing.TestRunner?}
+ * @private
+ */
+goog.testing.TestCase.prototype.testRunner_ = null;
+
+
+/**
+ * Adds a new test to the test case.
+ * @param {goog.testing.TestCase.Test} test The test to add.
+ */
+goog.testing.TestCase.prototype.add = function(test) {
+  this.tests_.push(test);
+};
+
+
+/**
+ * Returns the number of tests contained in the test case.
+ * @return {number} The number of tests.
+ */
+goog.testing.TestCase.prototype.getCount = function() {
+  return this.tests_.length;
+};
+
+
+/**
+ * Returns the current test and increments the pointer.
+ * @return {goog.testing.TestCase.Test?} The current test case.
+ */
+goog.testing.TestCase.prototype.next = function() {
+  var test;
+  while ((test = this.tests_[this.currentTestPointer_++])) {
+    if (!this.testsToRun_ || this.testsToRun_[test.name] ||
+        this.testsToRun_[this.currentTestPointer_ - 1]) {
+      return test;
+    }
+  }
+  return null;
+};
+
+
+/**
+ * Resets the test case pointer, so that next returns the first test.
+ */
+goog.testing.TestCase.prototype.reset = function() {
+  this.currentTestPointer_ = 0;
+  this.result_ = new goog.testing.TestCase.Result(this);
+};
+
+
+/**
+ * Sets the callback function that should be executed when the tests have
+ * completed.
+ * @param {Function} fn The callback function.
+ */
+goog.testing.TestCase.prototype.setCompletedCallback = function(fn) {
+  this.onCompleteCallback_ = fn;
+};
+
+
+/**
+ * Sets the test runner that is running this test case.
+ * @param {goog.testing.TestRunner} tr The test runner.
+ */
+goog.testing.TestCase.prototype.setTestRunner = function(tr) {
+  this.testRunner_ = tr;
+};
+
+
+/**
+ * Can be overridden in test classes to indicate whether the tests in a case
+ * should be run in that particular situation.  For example, this could be used
+ * to stop tests running in a particular browser, where browser support for
+ * the class under test was absent.
+ * @return {boolean} Whether any of the tests in the case should be run.
+ */
+goog.testing.TestCase.prototype.shouldRunTests = function() {
+  return true;
+};
+
+
+/**
+ * Executes each of the tests.
+ */
+goog.testing.TestCase.prototype.execute = function() {
+  this.started = true;
+  this.reset();
+  this.startTime_ = this.now_();
+  this.running = true;
+  this.result_.totalCount = this.getCount();
+
+  if (!this.shouldRunTests()) {
+    this.log('shouldRunTests() returned false, skipping these tests.');
+    this.result_.testSuppressed = true;
+    this.finalize();
+    return;
+  }
+
+  this.log('Starting tests: ' + this.name_);
+  this.cycleTests();
+};
+
+
+/**
+ * Finalizes the test case, called when the tests have finished executing.
+ */
+goog.testing.TestCase.prototype.finalize = function() {
+  this.saveMessage('Done');
+
+  this.tearDownPage();
+
+  var restoredSetTimeout =
+      goog.testing.TestCase.protectedTimeout_ == window.setTimeout;
+  if (!restoredSetTimeout && goog.testing.TestCase.IS_IE &&
+      String(window.setTimeout) == goog.testing.TestCase.setTimeoutAsString_) {
+    // In strange cases, IE's value of setTimeout *appears* to change, but
+    // the string representation stays stable.
+    restoredSetTimeout = true;
+  }
+
+  if (!restoredSetTimeout) {
+    var message = 'ERROR: Test did not restore setTimeout';
+    this.saveMessage(message);
+    var err = new goog.testing.TestCase.Error(this.name_, message);
+    this.result_.errors.push(err);
+  }
+  window.setTimeout = goog.testing.TestCase.protectedTimeout_;
+  this.endTime_ = this.now_();
+  this.running = false;
+  this.result_.runTime = this.endTime_ - this.startTime_;
+  this.result_.numFilesLoaded = this.countNumFilesLoaded_();
+
+  this.log(this.result_.getSummary());
+
+  if (this.result_.isSuccess()) {
+    this.log('Tests complete');
+  } else {
+    this.log('Tests Failed');
+  }
+  if (this.onCompleteCallback_) {
+    var fn = this.onCompleteCallback_;
+    // Execute's the completed callback in the context of the global object.
+    fn();
+    this.onCompleteCallback_ = null;
+  }
+};
+
+
+/**
+ * Saves a message to the result set.
+ * @param {string} message The message to save.
+ */
+goog.testing.TestCase.prototype.saveMessage = function(message) {
+  this.result_.messages.push(this.getTimeStamp_() + '  ' + message);
+};
+
+
+/**
+ * @return {boolean} Whether the test case is running inside the multi test
+ *     runner.
+ */
+goog.testing.TestCase.prototype.isInsideMultiTestRunner = function() {
+  var top = goog.global['top'];
+  return top && typeof top['_allTests'] != 'undefined';
+};
+
+
+/**
+ * Logs an object to the console, if available.
+ * @param {*} val The value to log. Will be ToString'd.
+ */
+goog.testing.TestCase.prototype.log = function(val) {
+  if (!this.isInsideMultiTestRunner() && window.console) {
+    if (typeof val == 'string') {
+      val = this.getTimeStamp_() + ' : ' + val;
+    }
+    window.console.log(val);
+  }
+};
+
+
+/**
+ * @return {boolean} Whether the test was a success.
+ */
+goog.testing.TestCase.prototype.isSuccess = function() {
+  return !!this.result_ && this.result_.isSuccess();
+};
+
+
+/**
+ * Returns a string detailing the results from the test.
+ * @param {boolean=} opt_verbose If true results will include data about all
+ *     tests, not just what failed.
+ * @return {string} The results from the test.
+ */
+goog.testing.TestCase.prototype.getReport = function(opt_verbose) {
+  var rv = [];
+  if (this.testRunner_ && !this.testRunner_.isFinished()) {
+    rv.push(this.name_ + ' [RUNNING]');
+  } else {
+    var success = this.result_.isSuccess() && !this.testRunner_.hasErrors();
+    rv.push(this.name_ + ' [' + (success ? 'PASSED' : 'FAILED') + ']');
+  }
+  rv.push(this.trimPath_(window.location.href));
+  rv.push(this.result_.getSummary());
+  if (opt_verbose) {
+    rv.push('.', this.result_.messages.join('\n'));
+  } else if (!this.result_.isSuccess()) {
+    rv.push(this.result_.errors.join('\n'));
+  }
+  rv.push(' ');
+  return rv.join('\n');
+};
+
+
+/**
+ * Returns the amount of time it took for the test to run.
+ * @return {number} The run time, in milliseconds.
+ */
+goog.testing.TestCase.prototype.getRunTime = function() {
+  return this.result_.runTime;
+};
+
+
+/**
+ * Returns the number of script files that were loaded in order to run the test.
+ * @return {number} The number of script files.
+ */
+goog.testing.TestCase.prototype.getNumFilesLoaded = function() {
+  return this.result_.numFilesLoaded;
+};
+
+
+/**
+ * Executes each of the tests.
+ * Overridable by the individual test case.  This allows test cases to defer
+ * when the test is actually started.  If overridden, finalize must be called
+ * by the test to indicate it has finished.
+ */
+goog.testing.TestCase.prototype.runTests = function() {
+  this.setUpPage();
+  this.execute();
+};
+
+
+/**
+ * Reorders the tests depending on the {@code order} field.
+ * @param {Array.<goog.testing.TestCase.Test>} tests An array of tests to
+ *     reorder.
+ * @private
+ */
+goog.testing.TestCase.prototype.orderTests_ = function(tests) {
+  switch (this.order) {
+    case goog.testing.TestCase.Order.RANDOM:
+      // Fisher-Yates shuffle
+      var i = tests.length;
+      while (i > 1) {
+        // goog.math.randomInt is inlined to reduce dependencies.
+        var j = Math.floor(Math.random() * i); // exclusive
+        i--;
+        var tmp = tests[i];
+        tests[i] = tests[j];
+        tests[j] = tmp;
+      }
+      break;
+
+    case goog.testing.TestCase.Order.SORTED:
+      tests.sort(function(t1, t2) {
+        if (t1.name == t2.name) {
+          return 0;
+        }
+        return t1.name < t2.name ? -1 : 1;
+      });
+      break;
+
+    // Do nothing for NATURAL.
+  }
+};
+
+
+/**
+ * Gets the object with all globals.
+ * @param {string=} opt_prefix An optional prefix. If specified, only get things
+ *     under this prefix.
+ * @return {Object} An object with all globals starting with the prefix.
+ */
+goog.testing.TestCase.prototype.getGlobals = function(opt_prefix) {
+  return goog.testing.TestCase.getGlobals(opt_prefix);
+};
+
+
+/**
+ * Gets the object with all globals.
+ * @param {string=} opt_prefix An optional prefix. If specified, only get things
+ *     under this prefix.
+ * @return {Object} An object with all globals starting with the prefix.
+ */
+goog.testing.TestCase.getGlobals = function(opt_prefix) {
+  // Look in the global scope for most browsers, on IE we use the little known
+  // RuntimeObject which holds references to all globals. We reference this
+  // via goog.global so that there isn't an aliasing that throws an exception
+  // in Firefox.
+  return typeof goog.global['RuntimeObject'] != 'undefined' ?
+      goog.global['RuntimeObject']((opt_prefix || '') + '*') : goog.global;
+};
+
+
+/**
+ * Gets called before any tests are executed.  Can be overridden to set up the
+ * environment for the whole test case.
+ */
+goog.testing.TestCase.prototype.setUpPage = function() {};
+
+
+/**
+ * Gets called after all tests have been executed.  Can be overridden to tear
+ * down the entire test case.
+ */
+goog.testing.TestCase.prototype.tearDownPage = function() {};
+
+
+/**
+ * Gets called before every goog.testing.TestCase.Test is been executed. Can be
+ * overridden to add set up functionality to each test.
+ */
+goog.testing.TestCase.prototype.setUp = function() {};
+
+
+/**
+ * Gets called after every goog.testing.TestCase.Test has been executed. Can be
+ * overriden to add tear down functionality to each test.
+ */
+goog.testing.TestCase.prototype.tearDown = function() {};
+
+
+/**
+ * @return {string} The function name prefix used to auto-discover tests.
+ * @protected
+ */
+goog.testing.TestCase.prototype.getAutoDiscoveryPrefix = function() {
+  return 'test';
+};
+
+
+/**
+ * @return {number} Time since the last batch of tests was started.
+ * @protected
+ */
+goog.testing.TestCase.prototype.getBatchTime = function() {
+  return this.batchTime_;
+};
+
+
+/**
+ * @param {number} batchTime Time since the last batch of tests was started.
+ * @protected
+ */
+goog.testing.TestCase.prototype.setBatchTime = function(batchTime) {
+  this.batchTime_ = batchTime;
+};
+
+
+/**
+ * Creates a {@code goog.testing.TestCase.Test} from an auto-discovered
+ *     function.
+ * @param {string} name The name of the function.
+ * @param {function() : void} ref The auto-discovered function.
+ * @return {goog.testing.TestCase.Test} The newly created test.
+ * @protected
+ */
+goog.testing.TestCase.prototype.createTestFromAutoDiscoveredFunction =
+    function(name, ref) {
+  return new goog.testing.TestCase.Test(name, ref, goog.global);
+};
+
+
+/**
+ * Adds any functions defined in the global scope that are prefixed with "test"
+ * to the test case.  Also overrides setUp, tearDown, setUpPage, tearDownPage
+ * and runTests if they are defined.
+ */
+goog.testing.TestCase.prototype.autoDiscoverTests = function() {
+  var prefix = this.getAutoDiscoveryPrefix();
+  var testSource = this.getGlobals(prefix);
+
+  var foundTests = [];
+
+  for (var name in testSource) {
+
+    try {
+      var ref = testSource[name];
+    } catch (ex) {
+      // NOTE(user): When running tests from a file:// URL on Firefox 3.5
+      // for Windows, any reference to window.sessionStorage raises
+      // an "Operation is not supported" exception. Ignore any exceptions raised
+      // by simply accessing global properties.
+    }
+
+    if ((new RegExp('^' + prefix)).test(name) && goog.isFunction(ref)) {
+      foundTests.push(this.createTestFromAutoDiscoveredFunction(name, ref));
+    }
+  }
+
+  this.orderTests_(foundTests);
+
+  for (var i = 0; i < foundTests.length; i++) {
+    this.add(foundTests[i]);
+  }
+
+  this.log(this.getCount() + ' tests auto-discovered');
+
+  // One-lining for readability.
+  if (goog.global['setUp']) this.setUp = goog.global['setUp'];
+  if (goog.global['tearDown']) this.tearDown = goog.global['tearDown'];
+  if (goog.global['setUpPage']) this.setUpPage = goog.global['setUpPage'];
+  if (goog.global['tearDownPage']) {
+    this.tearDownPage = goog.global['tearDownPage'];
+  }
+  if (goog.global['runTests']) this.runTests = goog.global['runTests'];
+  if (goog.global['shouldRunTests']) {
+      this.shouldRunTests = goog.global['shouldRunTests'];
+  }
+};
+
+
+/**
+ * Cycles through the tests, breaking out using a setTimeout if the execution
+ * time has execeeded {@link #MAX_RUN_TIME}.
+ */
+goog.testing.TestCase.prototype.cycleTests = function() {
+  this.saveMessage('Start');
+  this.batchTime_ = this.now_();
+  var nextTest;
+  while ((nextTest = this.next()) && this.running) {
+    this.result_.runCount++;
+    // Execute the test and handle the error, we execute all tests rather than
+    // stopping after a single error.
+    var cleanedUp = false;
+
+    try {
+      this.log('Running test: ' + nextTest.name);
+
+      goog.testing.TestCase.currentTestName = nextTest.name;
+      this.setUp();
+      nextTest.execute();
+      this.tearDown();
+      goog.testing.TestCase.currentTestName = null;
+
+      cleanedUp = true;
+
+      this.doSuccess(nextTest);
+    } catch (e) {
+      this.doError(nextTest, e);
+
+      if (!cleanedUp) {
+        try {
+          this.tearDown();
+        } catch (e2) {} // Fail silently if tearDown is throwing the errors.
+      }
+    }
+
+    // If the max run time is exceeded call this function again async so as not
+    // to block the browser.
+    if (this.currentTestPointer_ < this.tests_.length &&
+        this.now_() - this.batchTime_ > goog.testing.TestCase.MAX_RUN_TIME) {
+      this.saveMessage('Breaking async');
+      this.timeout(goog.bind(this.cycleTests, this), 100);
+      return;
+    }
+  }
+  // Tests are done.
+  this.finalize();
+};
+
+
+/**
+ * Counts the number of files that were loaded for dependencies that are
+ * required to run the test.
+ * @return {number} The number of files loaded.
+ * @private
+ */
+goog.testing.TestCase.prototype.countNumFilesLoaded_ = function() {
+  var scripts = document.getElementsByTagName('script');
+  var count = 0;
+  for (var i = 0, n = scripts.length; i < n; i++) {
+    if (scripts[i].src) {
+      count++;
+    }
+  }
+  return count;
+};
+
+
+/**
+ * Calls a function after a delay, using the protected timeout.
+ * @param {Function} fn The function to call.
+ * @param {number} time Delay in milliseconds.
+ * @return {number} The timeout id.
+ * @protected
+ */
+goog.testing.TestCase.prototype.timeout = function(fn, time) {
+  var protectedTimeout = goog.testing.TestCase.protectedTimeout_;
+  return protectedTimeout(fn, time);
+};
+
+
+/**
+ * @return {number} The current time in milliseconds, don't use goog.now as some
+ *     tests override it.
+ * @private
+ */
+goog.testing.TestCase.prototype.now_ = function() {
+  return new Date().getTime();
+};
+
+
+/**
+ * Returns the current time.
+ * @return {string} HH:MM:SS.
+ * @private
+ */
+goog.testing.TestCase.prototype.getTimeStamp_ = function() {
+  var d = new Date;
+
+  // Ensure millis are always 3-digits
+  var millis = '00' + d.getMilliseconds();
+  millis = millis.substr(millis.length - 3);
+
+  return this.pad_(d.getHours()) + ':' + this.pad_(d.getMinutes()) + ':' +
+         this.pad_(d.getSeconds()) + '.' + millis;
+};
+
+
+/**
+ * Pads a number to make it have a leading zero if it's less than 10.
+ * @param {number} number The number to pad.
+ * @return {string} The resulting string.
+ * @private
+ */
+goog.testing.TestCase.prototype.pad_ = function(number) {
+  return number < 10 ? '0' + number : String(number);
+};
+
+
+/**
+ * Trims a path to be only that after google3.
+ * @param {string} path The path to trim.
+ * @return {string} The resulting string.
+ * @private
+ */
+goog.testing.TestCase.prototype.trimPath_ = function(path) {
+  return path.substring(path.indexOf('google3') + 8);
+};
+
+
+/**
+ * Handles a test that passed.
+ * @param {goog.testing.TestCase.Test} test The test that passed.
+ * @protected
+ */
+goog.testing.TestCase.prototype.doSuccess = function(test) {
+  this.result_.successCount++;
+  var message = test.name + ' : PASSED';
+  this.saveMessage(message);
+  this.log(message);
+};
+
+
+/**
+ * Handles a test that failed.
+ * @param {goog.testing.TestCase.Test} test The test that failed.
+ * @param {string|Error=} opt_e The exception object associated with the
+ *     failure or a string.
+ * @protected
+ */
+goog.testing.TestCase.prototype.doError = function(test, opt_e) {
+  var message = test.name + ' : FAILED';
+  this.log(message);
+  this.saveMessage(message);
+  var err = this.logError(test.name, opt_e);
+  this.result_.errors.push(err);
+};
+
+
+/**
+ * @param {string} name Failed test name.
+ * @param {string|Error=} opt_e The exception object associated with the
+ *     failure or a string.
+ * @return {goog.testing.TestCase.Error} Error object.
+ */
+goog.testing.TestCase.prototype.logError = function(name, opt_e) {
+  var errMsg = null;
+  var stack = null;
+  if (opt_e) {
+    this.log(opt_e);
+    if (goog.isString(opt_e)) {
+      errMsg = opt_e;
+    } else {
+      errMsg = opt_e.message || opt_e.description || opt_e.toString();
+      stack = opt_e.stack ? goog.testing.stacktrace.canonicalize(opt_e.stack) :
+          opt_e['stackTrace'];
+    }
+  } else {
+    errMsg = 'An unknown error occurred';
+  }
+  var err = new goog.testing.TestCase.Error(name, errMsg, stack);
+
+  // Avoid double logging.
+  if (!opt_e || !opt_e['isJsUnitException'] ||
+      !opt_e['loggedJsUnitException']) {
+    this.saveMessage(err.toString());
+  }
+  if (opt_e && opt_e['isJsUnitException']) {
+    opt_e['loggedJsUnitException'] = true;
+  }
+
+  return err;
+};
+
+
+
+/**
+ * A class representing a single test function.
+ * @param {string} name The test name.
+ * @param {Function} ref Reference to the test function.
+ * @param {Object=} opt_scope Optional scope that the test function should be
+ *     called in.
+ * @constructor
+ */
+goog.testing.TestCase.Test = function(name, ref, opt_scope) {
+  /**
+   * The name of the test.
+   * @type {string}
+   */
+  this.name = name;
+
+  /**
+   * Reference to the test function.
+   * @type {Function}
+   */
+  this.ref = ref;
+
+  /**
+   * Scope that the test function should be called in.
+   * @type {Object}
+   */
+  this.scope = opt_scope || null;
+};
+
+
+/**
+ * Executes the test function.
+ */
+goog.testing.TestCase.Test.prototype.execute = function() {
+  this.ref.call(this.scope);
+};
+
+
+
+/**
+ * A class for representing test results.  A bag of public properties.
+ * @param {goog.testing.TestCase} testCase The test case that owns this result.
+ * @constructor
+ */
+goog.testing.TestCase.Result = function(testCase) {
+
+  /**
+   * The test case that owns this result.
+   * @type {goog.testing.TestCase}
+   * @private
+   */
+  this.testCase_ = testCase;
+
+  /**
+   * Total number of tests that should have been run.
+   * @type {number}
+   */
+  this.totalCount = 0;
+
+  /**
+   * Total number of tests that were actually run.
+   * @type {number}
+   */
+  this.runCount = 0;
+
+  /**
+   * Number of successful tests.
+   * @type {number}
+   */
+  this.successCount = 0;
+
+  /**
+   * The amount of time the tests took to run.
+   * @type {number}
+   */
+  this.runTime = 0;
+
+  /**
+   * The number of files loaded to run this test.
+   * @type {number}
+   */
+  this.numFilesLoaded = 0;
+
+  /**
+   * Whether this test case was suppressed by shouldRunTests() returning false.
+   * @type {boolean}
+   */
+  this.testSuppressed = false;
+
+  /**
+   * Errors encountered while running the test.
+   * @type {Array.<goog.testing.TestCase.Error>}
+   */
+  this.errors = [];
+
+  /**
+   * Messages to show the user after running the test.
+   * @type {Array.<string>}
+   */
+  this.messages = [];
+};
+
+
+/**
+ * @return {boolean} Whether the test was successful.
+ */
+goog.testing.TestCase.Result.prototype.isSuccess = function() {
+  var noErrors = this.runCount == this.successCount && this.errors.length == 0;
+  if (noErrors && !this.testSuppressed && this.isStrict()) {
+    return this.runCount > 0;
+  }
+  return noErrors;
+};
+
+
+/**
+ * @return {string} A summary of the tests, including total number of tests that
+ *     passed, failed, and the time taken.
+ */
+goog.testing.TestCase.Result.prototype.getSummary = function() {
+  var summary = this.runCount + ' of ' + this.totalCount + ' tests run in ' +
+      this.runTime + 'ms.\n';
+  if (this.testSuppressed) {
+    summary += 'Tests not run because shouldRunTests() returned false.';
+  } else if (this.runCount == 0) {
+    summary += 'No tests found.  ';
+    if (this.isStrict()) {
+      summary +=
+          'Call G_testRunner.setStrict(false) if this is expected behavior.  ';
+    }
+  } else {
+    summary += this.successCount + ' passed, ' +
+        (this.totalCount - this.successCount) + ' failed.\n' +
+        Math.round(this.runTime / this.runCount) + ' ms/test. ' +
+        this.numFilesLoaded + ' files loaded.';
+  }
+
+  return summary;
+};
+
+
+/**
+ * Determines whether the test result should report failure if no tests are run.
+ * @return {boolean} Whether this is strict.
+ */
+goog.testing.TestCase.Result.prototype.isStrict = function() {
+  return this.testCase_.testRunner_.isStrict();
+};
+
+
+
+/**
+ * A class representing an error thrown by the test
+ * @param {string} source The name of the test which threw the error.
+ * @param {string} message The error message.
+ * @param {string=} opt_stack A string showing the execution stack.
+ * @constructor
+ */
+goog.testing.TestCase.Error = function(source, message, opt_stack) {
+  /**
+   * The name of the test which threw the error.
+   * @type {string}
+   */
+  this.source = source;
+
+  /**
+   * Reference to the test function.
+   * @type {string}
+   */
+  this.message = message;
+
+  /**
+   * Scope that the test function should be called in.
+   * @type {?string}
+   */
+  this.stack = opt_stack || null;
+};
+
+
+/**
+ * Returns a string representing the error object.
+ * @return {string} A string representation of the error.
+ */
+goog.testing.TestCase.Error.prototype.toString = function() {
+  return 'ERROR in ' + this.source + '\n' +
+      this.message + (this.stack ? '\n' + this.stack : '');
+};