Fixing audit.js: should().beCloseTo() and task.run('taskName')

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 134 matching lines @@
         this._actualDescription =
             _generateDescription(this._actual, this._options);
       }
 
       if (!this._expectedDescription) {
         this._expectedDescription =
             _generateDescription(this._expected, this._options);
       }
 
       // For the assertion with a single operand.
-      this._detail = this._detail.replace('${actual}', this._actualDescription);
+      this._detail = this._detail.replace(
+          /\$\{actual\}/g, this._actualDescription);
 
       // If there is a second operand (i.e. expected value), we have to build
       // the string for it as well.
-      if (this._expected) {
+      if (this._expected !== null) {
         this._detail = this._detail.replace(
-            '${expected}', this._expectedDescription);
+            /\$\{expected\}/g, this._expectedDescription);
       }
 
       // If there is any property in |_options|, replace the property name
       // with the value.
       for (let name in this._options) {
-        this._detail = this._detail.replace(
-            '${' + name + '}',
+        if (name === 'numberOfErrors'

[Raymond Toy, 2016/12/08 00:06:02]

Why do you have to do this?

[hongchan, 2016/12/08 17:52:12]

Because we don't want to print out 'numberOfErrors' and etc in the logging. This
skips the loop for them, so it saves few iterations.

+            || name === 'numberOfArrayElements'
+            || 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]));
       }
     }
 
     _finalize () {
       if (this._result) {
         _logPassed('  ' + this._detail);
       } else {
         _logFailed('X ' + this._detail);
       }
@@ skipping 461 matching lines @@
         '${actual} has no glitch above the threshold of ${expected}.';
 
       return this._assert(passed, passDetail, failDetail);
     }
 
     /**
      * Check if |actual| is close to |expected| using the given relative error
      * |threshold|.
      *
      * @example
-     *   should(2.3).beCloseTo(2, 0.3);
+     *   should(2.3).beCloseTo(2, { threshold: 0.3 });
      *
      * @result
      *   "PASS    2.3 is 2 within an error of 0.3."
-     *
+     * @param {Object} options              Options for assertion.
      * @param {Number} options.threshold    Threshold value for the comparison.
      */
     beCloseTo () {
       this._processArguments(arguments);
 
       let absExpected = this._expected ? Math.abs(this._expected) : 1;

[Raymond Toy, 2016/12/08 00:06:02]

Because we got confused here when looking at it, we should comment that
beCloseTo threshold is relative, except when expected is zero, in which case
it's absolute.

[hongchan, 2016/12/08 17:52:11]

Done.

       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 a error of ${threshold}: ' +
+        error <= this._options.threshold,
+        '${actual} is ${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 257 matching lines @@
     // to execute them sequentially. Zero argument will perform all defined
     // tasks in the order of definition.
     run () {
       // Display the beginning of the test suite.
       _logPassed('# AUDIT TASK RUNNER STARTED.');
 
       // If the argument is specified, override the default task sequence with
       // the specified one.
       if (arguments.length > 0) {
         this._taskSequence = [];
-        for (let i = 0; arguments.length; i++) {
+        for (let i = 0; i < arguments.length; i++) {
           let taskLabel = arguments[i];
           if (!this._tasks.hasOwnProperty(taskLabel)) {
             _throwException('Audit.run:: undefined task.');
           } else if (this._taskSequence.includes(taskLabel)) {
             _throwException('Audit.run:: duplicate task request.');
           } else {
-            this._taskSequence.push[taskLabel];
+            this._taskSequence.push(taskLabel);
           }
         }
       }
 
       if (this._taskSequence.length === 0) {
         _throwException('Audit.run:: no task to run.');
         return;
       }
 
       // Start the first task.
       this._currentTaskIndex = 0;
       this._runNextTask();
     }
 
   }
 
 
   return {
 
     /**
      * Creates an instance of Audit task runner.
      */
     createTaskRunner: function () {
       return new TaskRunner();
     }
 
   };
 
 })();