Initial landing of Screen, Terminal, and VT100 classes.

chrome/browser/resources/hterm/js/test_manager.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 JavaScript unit testing framework for synchronous and
  *     asynchronous tests.
  *
  * This file contains the TestManager and related classes.  At the moment it's
  * all collected in a single file since it's reasonably small (=~1k lines), and
@@ skipping 314 matching lines @@
  * this suite's testcases.
  *
  * Any exception here will abort the remainder of the test run.
  *
  * @param {TestManager.Result} result The result object for the upcoming test.
  * @param {Object} cx The context object for a test run.
  */
 TestManager.Suite.prototype.preamble = function(result, cx) {};
 
 /**
+ * Subclassable method called to do post-test tear-down.
+ *
+ * The default implementation of this method is a no-op.  If your test suite
+ * requires some kind of pre-test setup, this is the place to do it.
+ *
+ * This can be used to avoid a bunch of boilerplate setup/teardown code in
+ * this suite's testcases.
+ *
+ * Any exception here will abort the remainder of the test run.
+ *
+ * @param {TestManager.Result} result The result object for the upcoming test.
+ * @param {Object} cx The context object for a test run.
+ */
+TestManager.Suite.prototype.postamble = function(result, cx) {};
+
+/**
  * Object representing a single test in a test suite.
  *
  * These are created as part of the TestManager.Suite.addTest() method.  You
  * should never have to construct one by hand.
  *
  * @param {TestManager.Suite} suiteClass The test suite class containing this
  *     test.
  * @param {string} testName The local name of this test case, not including the
  *     test suite name.
  * @param {function(TestManager.Result, Object)} testFunction The function to
@@ skipping 122 matching lines @@
  */
 TestManager.TestRun.prototype.ALL_TESTS = new String('<all-tests>');
 
 /**
  * Add a single test to the test run.
  */
 TestManager.TestRun.prototype.selectTest = function(test) {
   this.testQueue_.push(test);
 };
 
-TestManager.TestRun.prototype.selectSuite = function(suiteClass, pattern) {
+TestManager.TestRun.prototype.selectSuite = function(suiteClass, opt_pattern) {
+  var pattern = opt_pattern || this.ALL_TESTS;
   var selectCount = 0;
-
   var testList = suiteClass.getTestList();
 
   for (var j = 0; j < testList.length; j++) {
     var test = testList[j];
     // Note that we're using "!==" rather than "!=" so that we're matching
     // the ALL_TESTS String object, rather than the contents of the string.
     if (pattern !== this.ALL_TESTS) {
       if (pattern instanceof RegExp) {
         if (!pattern.test(test.testName))
           continue;
-      } else if (testName != pattern) {
+      } else if (test.testName != pattern) {
         continue;
       }
     }
 
     this.selectTest(test);
     selectCount++;
   }
 
   return selectCount;
 };
@@ skipping 29 matching lines @@
  * Hooked up to window.onerror during a test run in order to catch exceptions
  * that would otherwise go uncaught.
  */
 TestManager.TestRun.prototype.onUncaughtException_ = function(
     message, file, line) {
 
   if (message.indexOf('Uncaught TestManager.Result.TestComplete') == 0) {
     // This is a result.pass() or result.fail() call from a callback.  We're
     // already going to deal with it as part of the completeTest_() call
     // that raised it.  We can safely squelch this error message.
-    return false;
+    return true;
   }
 
   if (!this.currentResult)
     return;
 
   if (message == 'Uncaught ' + this.currentResult.expectedErrorMessage_) {
     // Test cases may need to raise an unhandled exception as part of the test.
     return;
   }
 
@@ skipping 47 matching lines @@
   this.testManager.onTestRunComplete(this);
 };
 
 /**
  * Called by the TestManager.Result object when a test completes.
  *
  * @param {TestManager.Result} result The result object which has just
  *     completed.
  */
 TestManager.TestRun.prototype.onResultComplete = function(result) {
+  try {
+    result.suite.postamble();
+  } catch (ex) {
+    this.log.println('Unexpected exception in postamble: ' +
+                     (ex.stack ? ex.stack : ex));
+    this.panic = true;
+  }
+
   this.log.popPrefix();
   this.log.print('} ' + result.status + ', ' +
                  this.msToSeconds_(result.duration));
   this.log.flush();
 
   if (result.status == result.FAILED) {
     this.failures.push(result);
     this.currentSuite = null;
   } else if (result.status == result.PASSED) {
     this.passes.push(result);
@@ skipping 124 matching lines @@
 
   window.onerror = this.onUncaughtException_.bind(this);
   this.startDate = new Date();
   this.runNextTest_();
 };
 
 /**
  * Format milliseconds as fractional seconds.
  */
 TestManager.TestRun.prototype.msToSeconds_ = function(ms) {
-  var secs = (ms / 100).toFixed(2);
+  var secs = (ms / 1000).toFixed(2);
   return secs + 's';
 };
 
 /**
  * Log the current result summary.
  */
 TestManager.TestRun.prototype.summarize = function() {
   if (this.failures.length) {
     for (var i = 0; i < this.failures.length; i++) {
       this.log.println('FAILED: ' + this.failures[i].test.fullName);
@@ skipping 259 matching lines @@
  * This will throw a TestCompleted exception, causing the current test to stop.
  *
  * @param {string} opt_message Optional message to add to the log.
  */
 TestManager.Result.prototype.pass  = function(opt_message) {
   if (arguments.length)
     this.println(opt_message);
 
   this.completeTest_(this.PASSED, true);
 };