Additional unit test for audit.js: failure cases and logging examples.

third_party/WebKit/LayoutTests/webaudio/resources/audit.js

 // Copyright 2016 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  WebAudio layout test utility library. Built around W3C's
  *                testharness.js. Includes asynchronous test task manager,
  *                assertion utilities.
  * @dependency    testharness.js
@@ skipping 284 matching lines @@
      */
     notThrow () {
       let didThrowCorrectly = false;
       let passDetail, failDetail;
 
       try {
         this._actual();
         passDetail = '${actual} did not throw an exception.';
       } catch (error) {
         didThrowCorrectly = true;
-        failDetail = '${actual} threw ' + error.name + ': '
-            + error.message + '.';
+        failDetail = '${actual} *INCORRECTLY* threw ' + error.name + ': "'

[Raymond Toy, 2016/12/09 22:10:26]

Do these really need to be highlighted?  The "FAIL" at the beginning of the line
is enough of a hint that something failed. (Plus the gross assert_foo failed at
the end is a pretty big indicator of failure.)

[hongchan, 2016/12/19 22:14:05]

Then do we remove all the *HIGHLIGHT*? I felt PASS/FAIL at the end is not really
visible.

+            + error.message + '".';
       }
 
       return this._assert(!didThrowCorrectly, passDetail, failDetail);
     }
 
     /**
      * Check if |actual| promise is resolved correctly.
      *
      * @example
      *   should('My promise', promise).beResolve().then(nextStuff);
@@ skipping 290 matching lines @@
         }
       }
 
       passed = !(indexActual < this._actual.length - 1
           || indexExpected < this._expected.length - 1);
 
       return this._assert(
           passed,
           '${actual} contains all the expected values in the correct order: '
             + '${expected}.',
-          '${actual} contains an unexpected value of '
+          '${actual} contains an *UNEXPECTED* value of '
             + this._actual[indexActual] + ' at index ' + indexActual + '.');
     }
 
     /**
      * Check if |actual| array does not have any glitches. Note that |threshold|
      * is not optional and is to define the desired threshold value.
      *
      * @example
      *   should([0.5, 0.5, 0.55, 0.5, 0.45, 0.5]).notGlitch(0.06);
      *
      * @result
      *   "PASS   [0.5,0.5,0.55,0.5,0.45,0.5] has no glitch above the threshold
      *           of 0.06."
      *
      */
     notGlitch () {
       this._processArguments(arguments);
 
       let passed = true;
       let passDetail, failDetail;
 
       for (let index in this._actual) {
         let diff = Math.abs(this._actual[index - 1] - this._actual[index]);
         if (diff >= this._expected) {
           passed = false;
-          failDetail = '${actual} has a glitch at index ' + index + ' of size '
+          failDetail = '${actual} has a *GLITCH* at index ' + index + ' of size '
             + diff + '.';
         }
       }
 
       passDetail =
         '${actual} has no glitch above the threshold of ${expected}.';
 
       return this._assert(passed, passDetail, failDetail);
     }
 
@@ skipping 13 matching lines @@
       this._processArguments(arguments);
 
       // The threshold is relative except when |expected| is zero, in which case
       // it is absolute.
       let absExpected = this._expected ? Math.abs(this._expected) : 1;
       let error = Math.abs(this._actual - this._expected) / absExpected;
 
       return this._assert(
         error <= this._options.threshold,
         '${actual} is ${expected} within an error of ${threshold}.',
-        '${actual} is not ${expected} within an error of ${threshold}: ' +
+        '${actual} is *NOT* ${expected} within an error of ${threshold}: ' +
           '${actual} with error of ${threshold}.');
     }
 
     /**
      * Check if |target| array is close to |expected| array element-wise within
      * a certain error bound given by the |options|.
      *
      * The error criterion is:
      *   abs(actual[k] - expected[k]) < max(absErr, relErr * abs(expected))
      *
@@ skipping 56 matching lines @@
         relativeThreshold: relErrorThreshold
       });
 
       if (numberOfErrors === 0) {
         // The assertion was successful.
         passDetail = '${actual} equals ${expected} with an element-wise '
           + 'tolerance of ' + maxAllowedErrorDetail + '.';
       } else {
         // Failed. Prepare the detailed failure log.
         passed = false;
-        failDetail = '${actual} does not equal ${expected} with an '
+        failDetail = '${actual} does *NOT* equal ${expected} with an '
           + 'element-wise tolerance of ' + maxAllowedErrorDetail + '.\n';
 
         // Print out actual, expected, absolute error, and relative error.
         let counter = 0;
         failDetail += '\tIndex\tActual\t\t\tExpected\t\tAbsError'
             + '\t\tRelError\t\tTest threshold';
         for (let index in errors) {
           failDetail += '\n\t[' + index + ']\t'
               + this._actual[index].toExponential(16) + '\t'
               + this._expected[index].toExponential(16) + '\t'
@@ skipping 217 matching lines @@
     /**
      * Creates an instance of Audit task runner.
      */
     createTaskRunner: function () {
       return new TaskRunner();
     }
 
   };
 
 })();