Optimize the speed of array iteration in Audit

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 548 matching lines @@
      *   "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 actual = this._actual;
+      let expected = this._expected;
+      for (let index = 0; index < actual.length; ++index) {
+        if (actual[index] !== expected)
+          errors[index] = 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 '
@@ skipping 27 matching lines @@
      */
     notBeConstantValueOf () {
       this._processArguments(arguments);
       this._printActualForFailure = false;
 
       let passed = true;
       let passDetail;
       let failDetail;
       let differences = {};
 
-      for (let index in this._actual) {
-        if (this._actual[index] !== this._expected)
-          differences[index] = this._actual[index];
+      let actual = this._actual;
+      let expected = this._expected;
+      for (let index = 0; index < actual.length; ++index) {
+        if (actual[index] !== expected)
+          differences[index] = actual[index];
       }
 
       let numberOfDifferences = Object.keys(differences).length;
       passed = numberOfDifferences > 0;
 
       if (passed) {
         let valueString = numberOfDifferences > 1 ? 'values' : 'value';
         passDetail = '${actual} is not constantly ${expected} (contains ' +
             numberOfDifferences + ' different ' + valueString + ').';
       } else {
@@ skipping 20 matching lines @@
       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);
       }
 
-      for (let index in this._actual) {
-        if (this._actual[index] !== this._expected[index])
+      let actual = this._actual;
+      let expected = this._expected;
+      for (let index = 0; index < actual.length; ++index) {
+        if (actual[index] !== expected[index])
           errorIndices.push(index);
       }
 
       passed = errorIndices.length === 0;
 
       if (passed) {
         passDetail = '${actual} is identical to the array ${expected}.';
       } else {
         let counter = 0;
         failDetail = '${actual} expected to be equal to the array ${expected} '
@@ skipping 74 matching lines @@
      *           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) {
+      let actual = this._actual;
+      let expected = this._expected;
+      for (let index = 0; index < actual.length; ++index) {
+        let diff = Math.abs(actual[index - 1] - actual[index]);
+        if (diff >= expected) {
           passed = false;
           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 60 matching lines @@
       // expected element.
       let errors = {};
 
       // Keep track of the max absolute error found.
       let maxAbsError = -Infinity, maxAbsErrorIndex = -1;
 
       // Keep track of the max relative error found, ignoring cases where the
       // relative error is Infinity because the expected value is 0.
       let maxRelError = -Infinity, maxRelErrorIndex = -1;
 
-      for (let index in this._expected) {
-        let diff = Math.abs(this._actual[index] - this._expected[index]);
-        let absExpected = Math.abs(this._expected[index]);
+      let actual = this._actual;
+      let expected = this._expected;
+
+      for (let index = 0; index < expected.length; ++index) {
+        let diff = Math.abs(actual[index] - expected[index]);
+        let absExpected = Math.abs(expected[index]);
         let relError = diff / absExpected;
 
         if (diff > Math.max(absErrorThreshold,
                             relErrorThreshold * absExpected)) {
 
           if (diff > maxAbsError) {
             maxAbsErrorIndex = index;
             maxAbsError = diff;
           }
 
@@ skipping 22 matching lines @@
         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' + _formatFailureEntry(
-                                   index, this._actual[index],
-                                   this._expected[index], errors[index],
+                                   index, actual[index],
+                                   expected[index], errors[index],
                                    _closeToThreshold(
                                        absErrorThreshold, relErrorThreshold,
-                                       this._expected[index]));
+                                       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';
         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],
+                  maxAbsErrorIndex, actual[maxAbsErrorIndex],
+                  expected[maxAbsErrorIndex], errors[maxAbsErrorIndex],
                   _closeToThreshold(
                       absErrorThreshold, relErrorThreshold,
-                      this._expected[maxAbsErrorIndex])) +
+                      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],
+                  maxRelErrorIndex, actual[maxRelErrorIndex],
+                  expected[maxRelErrorIndex], errors[maxRelErrorIndex],
                   _closeToThreshold(
                       absErrorThreshold, relErrorThreshold,
-                      this._expected[maxRelErrorIndex])) +
+                      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.
@@ skipping 316 matching lines @@
 
     /**
      * Load file from a given URL and pass ArrayBuffer to the following promise.
      * See |loadFileFromUrl| method for the detail.
      */
     loadFileFromUrl: loadFileFromUrl
 
   };
 
 })();