Provide detailed information on the test failure

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 80 matching lines @@
   class Should {
 
     constructor (parentTask, actual, actualDescription) {
       this._task = parentTask;
 
       this._actual = actual;
       this._actualDescription = (actualDescription || null);
       this._expected = null;
       this._expectedDescription = null;
 
-      this._result = true;
       this._detail = '';
+      this._printActualForFailure = true;
+
+      this._result = null;
 
       /**
        * @param {Number} numberOfErrors   Number of errors to be printed.
        * @param {Number} numberOfArrayElements  Number of array elements to be
        *                                        printed in the test log.
        * @param {Boolean} verbose         Verbose output from the assertion.
        */
       this._options = {
         numberOfErrors: 4,
         numberOfArrayElements: 16,
@@ skipping 12 matching lines @@
         // case 1: (expected, description, options)
         this._expectedDescription = args[1];
         Object.assign(this._options, args[2]);
       } else if (typeof args[1] === 'object') {
         // case 2: (expected, options)
         Object.assign(this._options, args[1]);
       }
     }
 
     _buildResultText () {
-      if (!this._actualDescription) {
-        this._actualDescription =
-            _generateDescription(this._actual, this._options);
-      }
+      if (this._result === null)
+        _throwException('Illegal invocation: the assertion is not finished.');
+
+      let actualString = _generateDescription(this._actual, this._options);
+
+      // Use generated text when the description is not provided.
+      if (!this._actualDescription)
+        this._actualDescription = actualString;
 
       if (!this._expectedDescription) {
         this._expectedDescription =
             _generateDescription(this._expected, this._options);
       }
 
       // For the assertion with a single operand.
       this._detail = this._detail.replace(
           /\$\{actual\}/g, this._actualDescription);
 
@@ skipping 12 matching lines @@
             || name === 'verbose') {
           continue;
         }
 
         // The RegExp key string contains special character. Take care of it.
         let re = '\$\{' + name + '\}';
         re = re.replace(/([.*+?^=!:${}()|\[\]\/\\])/g, '\\$1');
         this._detail = this._detail.replace(new RegExp(re, 'g'),
             _generateDescription(this._options[name]));
       }
+
+      // If the test failed, add the actual value at the end.
+      if (this._result === false && this._printActualForFailure === true) {
+        this._detail += ' Got ' + actualString + '.';
+      }
     }
 
     _finalize () {
       if (this._result) {
         _logPassed('  ' + this._detail);
       } else {
         _logFailed('X ' + this._detail);
       }
 
       // This assertion is finished, so update the parent task accordingly.
@@ skipping 60 matching lines @@
      *   should(() => { let a = b; }, 'A bad code').throw();
      *   should(() => { let c = d; }, 'Assigning d to c.')
      *       .throw('ReferenceError');
      *
      * @result
      *   "PASS   A bad code threw an exception of ReferenceError."
      *   "PASS   Assigning d to c threw ReferenceError."
      */
     throw () {
       this._processArguments(arguments);
+      this._printActualForFailure = false;
 
       let didThrowCorrectly = false;
       let passDetail, failDetail;
 
       try {
         // This should throw.
         this._actual();
         // Catch did not happen, so the test is failed.
         failDetail = '${actual} did not throw an exception.';
       } catch (error) {
@@ skipping 17 matching lines @@
      * Check if |actual| operation wrapped in a function does not throws an
      * exception correctly.
      *
      * @example
      *   should(() => { let foo = 'bar'; }, 'let foo = "bar"').notThrow();
      *
      * @result
      *   "PASS   let foo = "bar" did not throw an exception."
      */
     notThrow () {
+      this._printActualForFailure = false;
+
       let didThrowCorrectly = false;
       let passDetail, failDetail;
 
       try {
         this._actual();
         passDetail = '${actual} did not throw an exception.';
       } catch (error) {
         didThrowCorrectly = true;
         failDetail = '${actual} incorrectly threw ' + error.name + ': "'
             + error.message + '".';
@@ skipping 182 matching lines @@
      * Check if |actual| array is filled with a constant |expected| value.
      *
      * @example
      *   should([1, 1, 1]).beConstantValueOf(1);
      *
      * @result
      *   "PASS   [1,1,1] contains only the constant 1."
      */
     beConstantValueOf () {
       this._processArguments(arguments);
+      this._printActualForFailure = false;
 
       let passed = true;
       let passDetail, failDetail;
       let errors = {};
 
       for (let index in this._actual) {
         if (this._actual[index] !== this._expected)
           errors[index] = this._actual[index];
       }
 
       let numberOfErrors = Object.keys(errors).length;
       passed = numberOfErrors === 0;
 
       if (passed) {
         passDetail = '${actual} contains only the constant ${expected}.';
       } else {
         let counter = 0;
         failDetail = 'Expected ${expected} for all values but found '
-            + numberOfErrors + ' unexpected values. : ';
+            + numberOfErrors + ' unexpected values: ';
         failDetail += '\n\tIndex\tActual';
         for (let errorIndex in errors) {
           failDetail += '\n\t[' + errorIndex + ']'
               + '\t' + errors[errorIndex];
           if (++counter >= this._options.numberOfErrors) {
             failDetail += '\n\t...and ' + (numberOfErrors - counter)
               + ' more errors.';
             break;
           }
         }
       }
 
       return this._assert(passed, passDetail, failDetail);
     }
 
     /**
      * Check if |actual| array is identical to |expected| array element-wise.
      *
      * @example
      *   should([1, 2, 3]).beEqualToArray([1, 2, 3]);
      *
      * @result
      *   "[1,2,3] is identical to the array [1,2,3]."
      */
     beEqualToArray () {
       this._processArguments(arguments);
+      this._printActualForFailure = false;
 
       let passed = true;
       let passDetail, failDetail;
       let errorIndices = [];
 
       if (this._actual.length !== this._expected.length) {
         passed = false;
         failDetail = 'The array length does not match.';
         return this._assert(passed, passDetail, failDetail);
       }
@@ skipping 33 matching lines @@
      *
      * @example
      *   Should([1, 1, 3, 3, 2], 'My random array').containValues([1, 3, 2]);
      *
      * @result
      *   "PASS   [1,1,3,3,2] contains all the expected values in the correct
      *           order: [1,3,2].
      */
     containValues () {
       this._processArguments(arguments);
+      this._printActualForFailure = false;
 
       let passed = true;
       let indexedActual = [];
       let firstErrorIndex = null;
 
       // Collect the unique value sequence from the actual.
       for (let i = 0, prev = null; i < this._actual.length; i++) {
         if (this._actual[i] !== prev) {
           indexedActual.push({
               index: i,
@@ skipping 28 matching lines @@
      * @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);
+      this._printActualForFailure = false;
 
       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 '
             + diff + '.';
@@ skipping 19 matching lines @@
      * @param {Number} options.threshold    Threshold value for the comparison.
      */
     beCloseTo () {
       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;
 
+      // debugger;
+
       return this._assert(
           error <= this._options.threshold,
           '${actual} is ${expected} within an error of ${threshold}.',
-          '${actual} is not close to ${expected} within an error of ' +
-            '${threshold}');
+          '${actual} is not close to ${expected} within a relative error of ' +
+            '${threshold} (RelErr=' + error + ').');
     }
 
     /**
      * 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))
      *
      * If nothing is given for |options|, then absErr = relErr = 0. If
      * absErr = 0, then the error criterion is a relative error. A non-zero
      * absErr value produces a mix intended to handle the case where the
      * expected value is 0, allowing the target value to differ by absErr from
      * the expected.
      *
      * @param {Number} options.absoluteThreshold    Absolute threshold.
      * @param {Number} options.relativeThreshold    Relative threshold.
      */
     beCloseToArray () {
       this._processArguments(arguments);
+      this._printActualForFailure = false;
 
       let passed = true;
       let passDetail, failDetail;
 
       // Parsing options.
       let absErrorThreshold = (this._options.absoluteThreshold || 0);
       let relErrorThreshold = (this._options.relativeThreshold || 0);
 
       // A collection of all of the values that satisfy the error criterion.
       // This holds the absolute difference between the target element and the
@@ skipping 295 matching lines @@
         _logError('this test requires the explicit comparison with the '
             + 'expected result when it runs with run-webkit-tests.');
       }
 
       return new TaskRunner();
     }
 
   };
 
 })();