Print additional information on failed beCloseToArray tests

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 62 matching lines @@
         }
         break;
       default:
         targetString = String(target);
         break;
     }
 
     return targetString;
   }
 
+  // Return a string suitable for printing one failed element in
+  // |beCloseToArray|.
+  function _formatFailureEntry(index, actual, expected, abserr, threshold) {
+    return '\t[' + index + ']\t'
+      + actual.toExponential(16) + '\t'
+      + expected.toExponential(16) + '\t'
+      + abserr.toExponential(16) + '\t'
+      + (abserr / Math.abs(expected)).toExponential(16) + '\t'
+      + threshold.toExponential(16);
+  }
+
+  // Compute the error threshold criterion for |beCloseToArray|
+  function _closeToThreshold(abserr, relerr, expected) {
+    return Math.max(abserr, relerr * Math.abs(expected));
+  }
 
   /**
    * @class Should
    * @description Assertion subtask for the Audit task.
    * @param {Task} parentTask           Associated Task object.
    * @param {Any} actual                Target value to be tested.
    * @param {String} actualDescription  String description of the test target.
    */
   class Should {
 
@@ skipping 765 matching lines @@
       } else {
         // Failed. Prepare the detailed failure log.
         passed = false;
         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';
+        let printedIndices = [];
         for (let index in errors) {
-          failDetail += '\n\t[' + index + ']\t'
-              + this._actual[index].toExponential(16) + '\t'
-              + this._expected[index].toExponential(16) + '\t'
-              + errors[index].toExponential(16) + '\t'
-              + (errors[index] / Math.abs(this._expected[index]))
-                  .toExponential(16) + '\t'
-              + Math.max(absErrorThreshold,
-                    relErrorThreshold * Math.abs(this._expected[index]))
-                      .toExponential(16);
-          if (++counter > this._options.numberOfErrors)
+          failDetail += '\n' + _formatFailureEntry(
+                                   index, this._actual[index],
+                                   this._expected[index], errors[index],
+                                   _closeToThreshold(
+                                       absErrorThreshold, relErrorThreshold,
+                                       this._expected[index]));
+
+          printedIndices.push(index);
+          if (++counter > this._options.numberOfErrors) {
+            failDetail +=
+                '\n\t...and ' + (numberOfErrors - counter) + ' more errors.';
             break;
+          }
         }
 
         // Finalize the error log: print out the location of both the maxAbs
         // error and the maxRel error so we can adjust thresholds appropriately
         // in the test.
         failDetail += '\n'
             + '\tMax AbsError of ' + maxAbsError.toExponential(16)
-            + ' at index of ' + maxAbsErrorIndex + '.\n'
-            + '\tMax RelError of ' + maxRelError.toExponential(16)
-            + ' at index of ' + maxRelErrorIndex + '.';
+            + ' at index of ' + maxAbsErrorIndex + '.\n';
+        if (printedIndices.find(element => {
+              return element == maxAbsErrorIndex;
+            }) === undefined) {
+          // Print an entry for this index if we haven't already.
+          failDetail +=
+              _formatFailureEntry(
+                  maxAbsErrorIndex, this._actual[maxAbsErrorIndex],
+                  this._expected[maxAbsErrorIndex], errors[maxAbsErrorIndex],
+                  _closeToThreshold(
+                      absErrorThreshold, relErrorThreshold,
+                      this._expected[maxAbsErrorIndex])) +
+              '\n';
+        }
+        failDetail += '\tMax RelError of ' + maxRelError.toExponential(16) +
+            ' at index of ' + maxRelErrorIndex + '.\n';
+        if (printedIndices.find(element => {
+              return element == maxRelErrorIndex;
+            }) === undefined) {
+          // Print an entry for this index if we haven't already.
+          failDetail +=
+              _formatFailureEntry(
+                  maxRelErrorIndex, this._actual[maxRelErrorIndex],
+                  this._expected[maxRelErrorIndex], errors[maxRelErrorIndex],
+                  _closeToThreshold(
+                      absErrorThreshold, relErrorThreshold,
+                      this._expected[maxRelErrorIndex])) +
+              '\n';
+        }
       }
 
       return this._assert(passed, passDetail, failDetail);
     }
 
     /**
      * A temporary escape hat for printing an in-task message. The description
      * for the |actual| is required to get the message printed properly.
      *
      * TODO(hongchan): remove this method when the transition from the old Audit
@@ skipping 283 matching lines @@
 
     /**
      * Load file from a given URL and pass ArrayBuffer to the following promise.
      * See |loadFileFromUrl| method for the detail.
      */
     loadFileFromUrl: loadFileFromUrl
 
   };
 
 })();