SSL audit.js   Sprache: JAVA

// Copyright 2016 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

// See https://github.com/web-platform-tests/wpt/issues/12781 for information on
// the purpose of audit.js, and why testharness.js does not suffice.

/**
 * @fileOverview  WebAudio layout test utility library. Built around W3C's
 *                testharness.js. Includes asynchronous test task manager,
 *                assertion utilities.
 * @dependency    testharness.js
 */


(function() {

  'use strict';

  // Selected methods from testharness.js.
  let testharnessProperties = [
    'test', 'async_test', 'promise_test', 'promise_rejects_js', 'generate_tests',
    'setup', 'done', 'assert_true', 'assert_false'
  ];

  // Check if testharness.js is properly loaded. Throw otherwise.
  for (let name in testharnessProperties) {
    if (!self.hasOwnProperty(testharnessProperties[name]))
      throw new Error('Cannot proceed. testharness.js is not loaded.');
  }
})();


window.Audit = (function() {

  'use strict';

  // NOTE: Moving this method (or any other code above) will change the location
  // of 'CONSOLE ERROR...' message in the expected text files.
  function _logError(message) {
    console.error('[audit.js] ' + message);
  }

  function _logPassed(message) {
    test(function(arg) {
      assert_true(true);
    }, message);
  }

  function _logFailed(message, detail) {
    test(function() {
      assert_true(false, detail);
    }, message);
  }

  function _throwException(message) {
    throw new Error(message);
  }

  // TODO(hongchan): remove this hack after confirming all the tests are
  // finished correctly. (crbug.com/708817)
  const _testharnessDone = window.done;
  window.done = () => {
    _throwException('Do NOT call done() method from the test code.');
  };

  // Generate a descriptive string from a target value in various types.
  function _generateDescription(target, options) {
    let targetString;

    switch (typeof target) {
      case 'object':
        // Handle Arrays.
        if (target instanceof Array || target instanceof Float32Array ||
            target instanceof Float64Array || target instanceof Uint8Array) {
          let arrayElements = target.length < options.numberOfArrayElements ?
              String(target) :
              String(target.slice(0, options.numberOfArrayElements)) + '...';
          targetString = '[' + arrayElements + ']';
        } else if (target === null) {
          targetString = String(target);
        } else {
          targetString = '' + String(target).split(/[\s\]]/)[1];
        }
        break;
      case 'function':
        if (Error.isPrototypeOf(target)) {
          targetString = "EcmaScript error " + target.name;
        } else {
          targetString = String(target);
        }
        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 {
    constructor(parentTask, actual, actualDescription) {
      this._task = parentTask;

      this._actual = actual;
      this._actualDescription = (actualDescription || null);
      this._expected = null;
      this._expectedDescription = null;

      this._detail = '';
      // If true and the test failed, print the actual value at the
      // end of the message.
      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,
        verbose: false
      };
    }

    _processArguments(args) {
      if (args.length === 0)
        return;

      if (args.length > 0)
        this._expected = args[0];

      if (typeof args[1] === 'string') {
        // 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._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);

      // If there is a second operand (i.e. expected value), we have to build
      // the string for it as well.
      this._detail =
          this._detail.replace(/\$\{expected\}/g, this._expectedDescription);

      // If there is any property in |_options|, replace the property name
      // with the value.
      for (let name in this._options) {
        if (name === 'numberOfErrors' || 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]));
      }

      // 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.
      this._task.update(this);

      // TODO(hongchan): configurable 'detail' message.
    }

    _assert(condition, passDetail, failDetail) {
      this._result = Boolean(condition);
      this._detail = this._result ? passDetail : failDetail;
      this._buildResultText();
      this._finalize();

      return this._result;
    }

    get result() {
      return this._result;
    }

    get detail() {
      return this._detail;
    }

    /**
     * should() assertions.
     *
     * @example All the assertions can have 1, 2 or 3 arguments:
     *   should().doAssert(expected);
     *   should().doAssert(expected, options);
     *   should().doAssert(expected, expectedDescription, options);
     *
     * @param {Any} expected                  Expected value of the assertion.
     * @param {String} expectedDescription    Description of expected value.
     * @param {Object} options                Options for assertion.
     * @param {Number} options.numberOfErrors Number of errors to be printed.
     *                                        (if applicable)
     * @param {Number} options.numberOfArrayElements  Number of array elements
     *                                                to be printed. (if
     *                                                applicable)
     * @notes Some assertions can have additional options for their specific
     *        testing.
     */

    /**
     * Check if |actual| exists.
     *
     * @example
     *   should({}, 'An empty object').exist();
     * @result
     *   "PASS   An empty object does exist."
     */
    exist() {
      return this._assert(
          this._actual !== null && this._actual !== undefined,
          '${actual} does exist.', '${actual} does not exist.');
    }

    /**
     * Check if |actual| operation wrapped in a function throws an exception
     * with a expected error type correctly. |expected| is optional. If it is an
     * instance of DOMException, then the description (second argument) can be
     * provided to be more strict about the expected exception type. |expected|
     * also can be other generic error types such as TypeError, RangeError or
     * etc.
     *
     * @example
     *   should(() => { let a = b; }, 'A bad code').throw();
     *   should(() => { new SomeConstructor(); }, 'A bad construction')
     *       .throw(DOMException, 'NotSupportedError');
     *   should(() => { let c = d; }, 'Assigning d to c')
     *       .throw(ReferenceError);
     *   should(() => { let e = f; }, 'Assigning e to f')
     *       .throw(ReferenceError, { omitErrorMessage: true });
     *
     * @result
     *   "PASS   A bad code threw an exception of ReferenceError: b is not
     *       defined."
     *   "PASS   A bad construction threw DOMException:NotSupportedError."
     *   "PASS   Assigning d to c threw ReferenceError: d is not defined."
     *   "PASS   Assigning e to f threw ReferenceError: [error message
     *       omitted]."
     */
    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) {
        let errorMessage = this._options.omitErrorMessage ?
            ': [error message omitted]' :
            ': "' + error.message + '"';
        if (this._expected === null || this._expected === undefined) {
          // The expected error type was not given.
          didThrowCorrectly = true;
          passDetail = '${actual} threw ' + error.name + errorMessage + '.';
        } else if (this._expected === DOMException &&
                   this._expectedDescription !== undefined) {
          // Handles DOMException with an expected exception name.
          if (this._expectedDescription === error.name) {
            didThrowCorrectly = true;
            passDetail = '${actual} threw ${expected}' + errorMessage + '.';
          } else {
            didThrowCorrectly = false;
            failDetail =
                '${actual} threw "' + error.name + '" instead of ${expected}.';
          }
        } else if (this._expected == error.constructor) {
          // Handler other error types.
          didThrowCorrectly = true;
          passDetail = '${actual} threw ' + error.name + errorMessage + '.';
        } else {
          didThrowCorrectly = false;
          failDetail =
              '${actual} threw "' + error.name + '" instead of ${expected}.';
        }
      }

      return this._assert(didThrowCorrectly, passDetail, failDetail);
    }

    /**
     * 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 + '".';
      }

      return this._assert(!didThrowCorrectly, passDetail, failDetail);
    }

    /**
     * Check if |actual| promise is resolved correctly. Note that the returned
     * result from promise object will be passed to the following then()
     * function.
     *
     * @example
     *   should('My promise', promise).beResolve().then((result) => {
     *     log(result);
     *   });
     *
     * @result
     *   "PASS   My promise resolved correctly."
     *   "FAIL X My promise rejected *INCORRECTLY* with _ERROR_."
     */
    beResolved() {
      return this._actual.then(
          function(result) {
            this._assert(true, '${actual} resolved correctly.', null);
            return result;
          }.bind(this),
          function(error) {
            this._assert(
                false, null,
                '${actual} rejected incorrectly with ' + error + '.');
          }.bind(this));
    }

    /**
     * Check if |actual| promise is rejected correctly.
     *
     * @example
     *   should('My promise', promise).beRejected().then(nextStuff);
     *
     * @result
     *   "PASS   My promise rejected correctly (with _ERROR_)."
     *   "FAIL X My promise resolved *INCORRECTLY*."
     */
    beRejected() {
      return this._actual.then(
          function() {
            this._assert(false, null, '${actual} resolved incorrectly.');
          }.bind(this),
          function(error) {
            this._assert(
                true, '${actual} rejected correctly with ' + error + '.', null);
          }.bind(this));
    }

    /**
     * Check if |actual| promise is rejected correctly.
     *
     * @example
     *   should(promise, 'My promise').beRejectedWith('_ERROR_').then();
     *
     * @result
     *   "PASS   My promise rejected correctly with _ERROR_."
     *   "FAIL X My promise rejected correctly but got _ACTUAL_ERROR instead of
     *           _EXPECTED_ERROR_."
     *   "FAIL X My promise resolved incorrectly."
     */
    beRejectedWith() {
      this._processArguments(arguments);

      return this._actual.then(
          function() {
            this._assert(false, null, '${actual} resolved incorrectly.');
          }.bind(this),
          function(error) {
            if (this._expected !== error.name) {
              this._assert(
                  false, null,
                  '${actual} rejected correctly but got ' + error.name +
                      ' instead of ' + this._expected + '.');
            } else {
              this._assert(
                  true,
                  '${actual} rejected correctly with ' + this._expected + '.',
                  null);
            }
          }.bind(this));
    }

    /**
     * Check if |actual| is a boolean true.
     *
     * @example
     *   should(3 < 5, '3 < 5').beTrue();
     *
     * @result
     *   "PASS   3 < 5 is true."
     */
    beTrue() {
      return this._assert(
          this._actual === true, '${actual} is true.',
          '${actual} is not true.');
    }

    /**
     * Check if |actual| is a boolean false.
     *
     * @example
     *   should(3 > 5, '3 > 5').beFalse();
     *
     * @result
     *   "PASS   3 > 5 is false."
     */
    beFalse() {
      return this._assert(
          this._actual === false, '${actual} is false.',
          '${actual} is not false.');
    }

    /**
     * Check if |actual| is strictly equal to |expected|. (no type coercion)
     *
     * @example
     *   should(1).beEqualTo(1);
     *
     * @result
     *   "PASS   1 is equal to 1."
     */
    beEqualTo() {
      this._processArguments(arguments);
      return this._assert(
          this._actual === this._expected, '${actual} is equal to ${expected}.',
          '${actual} is not equal to ${expected}.');
    }

    /**
     * Check if |actual| is not equal to |expected|.
     *
     * @example
     *   should(1).notBeEqualTo(2);
     *
     * @result
     *   "PASS   1 is not equal to 2."
     */
    notBeEqualTo() {
      this._processArguments(arguments);
      return this._assert(
          this._actual !== this._expected,
          '${actual} is not equal to ${expected}.',
          '${actual} should not be equal to ${expected}.');
    }

    /**
     * check if |actual| is NaN
     *
     * @example
     *   should(NaN).beNaN();
     *
     * @result
     *   "PASS   NaN is NaN"
     *
     */
    beNaN() {
      this._processArguments(arguments);
      return this._assert(
          isNaN(this._actual),
          '${actual} is NaN.',
          '${actual} is not NaN but should be.');
    }

    /**
     * check if |actual| is NOT NaN
     *
     * @example
     *   should(42).notBeNaN();
     *
     * @result
     *   "PASS   42 is not NaN"
     *
     */
    notBeNaN() {
      this._processArguments(arguments);
      return this._assert(
          !isNaN(this._actual),
          '${actual} is not NaN.',
          '${actual} is NaN but should not be.');
    }

    /**
     * Check if |actual| is greater than |expected|.
     *
     * @example
     *   should(2).beGreaterThanOrEqualTo(2);
     *
     * @result
     *   "PASS   2 is greater than or equal to 2."
     */
    beGreaterThan() {
      this._processArguments(arguments);
      return this._assert(
          this._actual > this._expected,
          '${actual} is greater than ${expected}.',
          '${actual} is not greater than ${expected}.');
    }

    /**
     * Check if |actual| is greater than or equal to |expected|.
     *
     * @example
     *   should(2).beGreaterThan(1);
     *
     * @result
     *   "PASS   2 is greater than 1."
     */
    beGreaterThanOrEqualTo() {
      this._processArguments(arguments);
      return this._assert(
          this._actual >= this._expected,
          '${actual} is greater than or equal to ${expected}.',
          '${actual} is not greater than or equal to ${expected}.');
    }

    /**
     * Check if |actual| is less than |expected|.
     *
     * @example
     *   should(1).beLessThan(2);
     *
     * @result
     *   "PASS   1 is less than 2."
     */
    beLessThan() {
      this._processArguments(arguments);
      return this._assert(
          this._actual < this._expected, '${actual} is less than ${expected}.',
          '${actual} is not less than ${expected}.');
    }

    /**
     * Check if |actual| is less than or equal to |expected|.
     *
     * @example
     *   should(1).beLessThanOrEqualTo(1);
     *
     * @result
     *   "PASS   1 is less than or equal to 1."
     */
    beLessThanOrEqualTo() {
      this._processArguments(arguments);
      return this._assert(
          this._actual <= this._expected,
          '${actual} is less than or equal to ${expected}.',
          '${actual} is not less than or equal to ${expected}.');
    }

    /**
     * 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 = {};

      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 =
            '${actual}: Expected ${expected} for all values but found ' +
            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 not filled with a constant |expected| value.
     *
     * @example
     *   should([1, 0, 1]).notBeConstantValueOf(1);
     *   should([0, 0, 0]).notBeConstantValueOf(0);
     *
     * @result
     *   "PASS   [1,0,1] is not constantly 1 (contains 1 different value)."
     *   "FAIL X [0,0,0] should have contain at least one value different
     *     from 0."
     */
    notBeConstantValueOf() {
      this._processArguments(arguments);
      this._printActualForFailure = false;

      let passed = true;
      let passDetail;
      let failDetail;
      let differences = {};

      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 {
        failDetail = '${actual} should have contain at least one value ' +
            'different from ${expected}.';
      }

      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);
      }

      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} ' +
            'but differs in ' + errorIndices.length + ' places:' +
            '\n\tIndex\tActual\t\t\tExpected';
        for (let index of errorIndices) {
          failDetail += '\n\t[' + index + ']' +
              '\t' + this._actual[index].toExponential(16) + '\t' +
              this._expected[index].toExponential(16);
          if (++counter >= this._options.numberOfErrors) {
            failDetail += '\n\t...and ' + (errorIndices.length - counter) +
                ' more errors.';
            break;
          }
        }
      }

      return this._assert(passed, passDetail, failDetail);
    }

    /**
     * Check if |actual| array contains only the values in |expected| in the
     * order of values in |expected|.
     *
     * @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, value: this._actual[i]});
          prev = this._actual[i];
        }
      }

      // Compare against the expected sequence.
      let failMessage =
          '${actual} expected to have the value sequence of ${expected} but ' +
          'got ';
      if (this._expected.length === indexedActual.length) {
        for (let j = 0; j < this._expected.length; j++) {
          if (this._expected[j] !== indexedActual[j].value) {
            firstErrorIndex = indexedActual[j].index;
            passed = false;
            failMessage += this._actual[firstErrorIndex] + ' at index ' +
                firstErrorIndex + '.';
            break;
          }
        }
      } else {
        passed = false;
        let indexedValues = indexedActual.map(x => x.value);
        failMessage += `${indexedActual.length} values, [${
            indexedValues}], instead of ${this._expected.length}.`;
      }

      return this._assert(
          passed,
          '${actual} contains all the expected values in the correct order: ' +
              '${expected}.',
          failMessage);
    }

    /**
     * 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);
      this._printActualForFailure = false;

      let passed = true;
      let passDetail, failDetail;

      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);
    }

    /**
     * Check if |actual| is close to |expected| using the given relative error
     * |threshold|.
     *
     * @example
     *   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);

      // 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 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
      // 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;

      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;
          }

          if (!isNaN(relError) && relError > maxRelError) {
            maxRelErrorIndex = index;
            maxRelError = relError;
          }

          errors[index] = diff;
        }
      }

      let numberOfErrors = Object.keys(errors).length;
      let maxAllowedErrorDetail = JSON.stringify({
        absoluteThreshold: absErrorThreshold,
        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 ' +
            '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, actual[index], expected[index], errors[index],
                  _closeToThreshold(
                      absErrorThreshold, relErrorThreshold, 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, actual[maxAbsErrorIndex],
                  expected[maxAbsErrorIndex], errors[maxAbsErrorIndex],
                  _closeToThreshold(
                      absErrorThreshold, relErrorThreshold,
                      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, actual[maxRelErrorIndex],
                  expected[maxRelErrorIndex], errors[maxRelErrorIndex],
                  _closeToThreshold(
                      absErrorThreshold, relErrorThreshold,
                      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
     * to the new Audit is completed.
     * @example
     *   should(true, 'The message is').message('truthful!', 'false!');
     *
     * @result
     *   "PASS   The message is truthful!"
     */
    message(passDetail, failDetail) {
      return this._assert(
          this._actual, '${actual} ' + passDetail, '${actual} ' + failDetail);
    }

    /**
     * Check if |expected| property is truly owned by |actual| object.
     *
     * @example
     *   should(BaseAudioContext.prototype,
     *          'BaseAudioContext.prototype').haveOwnProperty('createGain');
     *
     * @result
     *   "PASS   BaseAudioContext.prototype has an own property of
     *       'createGain'."
     */
    haveOwnProperty() {
      this._processArguments(arguments);

      return this._assert(
          this._actual.hasOwnProperty(this._expected),
          '${actual} has an own property of "${expected}".',
          '${actual} does not own the property of "${expected}".');
    }


    /**
     * Check if |expected| property is not owned by |actual| object.
     *
     * @example
     *   should(BaseAudioContext.prototype,
     *          'BaseAudioContext.prototype')
     *       .notHaveOwnProperty('startRendering');
     *
     * @result
     *   "PASS   BaseAudioContext.prototype does not have an own property of
     *       'startRendering'."
     */
    notHaveOwnProperty() {
      this._processArguments(arguments);

      return this._assert(
          !this._actual.hasOwnProperty(this._expected),
          '${actual} does not have an own property of "${expected}".',
          '${actual} has an own the property of "${expected}".')
    }


    /**
     * Check if an object is inherited from a class. This looks up the entire
     * prototype chain of a given object and tries to find a match.
     *
     * @example
     *   should(sourceNode, 'A buffer source node')
     *       .inheritFrom('AudioScheduledSourceNode');
     *
     * @result
     *   "PASS   A buffer source node inherits from 'AudioScheduledSourceNode'."
     */
    inheritFrom() {
      this._processArguments(arguments);

      let prototypes = [];
      let currentPrototype = Object.getPrototypeOf(this._actual);
      while (currentPrototype) {
        prototypes.push(currentPrototype.constructor.name);
        currentPrototype = Object.getPrototypeOf(currentPrototype);
      }

      return this._assert(
          prototypes.includes(this._expected),
          '${actual} inherits from "${expected}".',
          '${actual} does not inherit from "${expected}".');
    }
  }


  // Task Class state enum.
  const TaskState = {PENDING: 0, STARTED: 1, FINISHED: 2};


  /**
   * @class Task
   * @description WebAudio testing task. Managed by TaskRunner.
   */
  class Task {
    /**
     * Task constructor.
     * @param  {Object} taskRunner Reference of associated task runner.
     * @param  {String||Object} taskLabel Task label if a string is given. This
     *                                    parameter can be a dictionary with the
     *                                    following fields.
     * @param  {String} taskLabel.label Task label.
     * @param  {String} taskLabel.description Description of task.
     * @param  {Function} taskFunction Task function to be performed.
     * @return {Object} Task object.
     */
    constructor(taskRunner, taskLabel, taskFunction) {
      this._taskRunner = taskRunner;
      this._taskFunction = taskFunction;

      if (typeof taskLabel === 'string') {
        this._label = taskLabel;
        this._description = null;
      } else if (typeof taskLabel === 'object') {
        if (typeof taskLabel.label !== 'string') {
          _throwException('Task.constructor:: task label must be string.');
        }
        this._label = taskLabel.label;
        this._description = (typeof taskLabel.description === 'string') ?
            taskLabel.description :
            null;
      } else {
        _throwException(
            'Task.constructor:: task label must be a string or ' +
            'a dictionary.');
      }

      this._state = TaskState.PENDING;
      this._result = true;

      this._totalAssertions = 0;
      this._failedAssertions = 0;
    }

    get label() {
      return this._label;
    }

    get state() {
      return this._state;
    }

    get result() {
      return this._result;
    }

    // Start the assertion chain.
    should(actual, actualDescription) {
      // If no argument is given, we cannot proceed. Halt.
      if (arguments.length === 0)
        _throwException('Task.should:: requires at least 1 argument.');

      return new Should(this, actual, actualDescription);
    }

    // Run this task. |this| task will be passed into the user-supplied test
    // task function.
    run(harnessTest) {
      this._state = TaskState.STARTED;
      this._harnessTest = harnessTest;
      // Print out the task entry with label and description.
      _logPassed(
          '> [' + this._label + '] ' +
          (this._description ? this._description : ''));

      return new Promise((resolve, reject) => {
        this._resolve = resolve;
        this._reject = reject;
        let result = this._taskFunction(this, this.should.bind(this));
        if (result && typeof result.then === "function") {
          result.then(() => this.done()).catch(reject);
        }
      });
    }

    // Update the task success based on the individual assertion/test inside.
    update(subTask) {
      // After one of tests fails within a task, the result is irreversible.
      if (subTask.result === false) {
        this._result = false;
        this._failedAssertions++;
      }

      this._totalAssertions++;
    }

    // Finish the current task and start the next one if available.
    done() {
      assert_equals(this._state, TaskState.STARTED)
      this._state = TaskState.FINISHED;

      let message = '< [' + this._label + '] ';

      if (this._result) {
        message += 'All assertions passed. (total ' + this._totalAssertions +
            ' assertions)';
        _logPassed(message);
      } else {
        message += this._failedAssertions + ' out of ' + this._totalAssertions +
            ' assertions were failed.'
        _logFailed(message);
      }

      this._resolve();
    }

    // Runs |subTask| |time| milliseconds later. |setTimeout| is not allowed in
    // WPT linter, so a thin wrapper around the harness's |step_timeout| is
    // used here.  Returns a Promise which is resolved after |subTask| runs.
    timeout(subTask, time) {
      return new Promise(resolve => {
        this._harnessTest.step_timeout(() => {
          let result = subTask();
          if (result && typeof result.then === "function") {
            // Chain rejection directly to the harness test Promise, to report
            // the rejection against the subtest even when the caller of
            // timeout does not handle the rejection.
            result.then(resolve, this._reject());
          } else {
            resolve();
          }
        }, time);
      });
    }

    isPassed() {
      return this._state === TaskState.FINISHED && this._result;
    }

    toString() {
      return '"' + this._label + '": ' + this._description;
    }
  }


  /**
   * @class TaskRunner
   * @description WebAudio testing task runner. Manages tasks.
   */
  class TaskRunner {
    constructor() {
      this._tasks = {};
      this._taskSequence = [];

      // Configure testharness.js for the async operation.
      setup(new Function(), {explicit_done: true});
    }

    _finish() {
      let numberOfFailures = 0;
      for (let taskIndex in this._taskSequence) {
        let task = this._tasks[this._taskSequence[taskIndex]];
        numberOfFailures += task.result ? 0 : 1;
      }

      let prefix = '# AUDIT TASK RUNNER FINISHED: ';
      if (numberOfFailures > 0) {
        _logFailed(
            prefix + numberOfFailures + ' out of ' + this._taskSequence.length +
            ' tasks were failed.');
      } else {
        _logPassed(
            prefix + this._taskSequence.length + ' tasks ran successfully.');
      }

      return Promise.resolve();
    }

    // |taskLabel| can be either a string or a dictionary. See Task constructor
    // for the detail.  If |taskFunction| returns a thenable, then the task
    // is considered complete when the thenable is fulfilled; otherwise the
    // task must be completed with an explicit call to |task.done()|.
    define(taskLabel, taskFunction) {
      let task = new Task(this, taskLabel, taskFunction);
      if (this._tasks.hasOwnProperty(task.label)) {
        _throwException('Audit.define:: Duplicate task definition.');
        return;
      }
      this._tasks[task.label] = task;
      this._taskSequence.push(task.label);
    }

    // Start running all the tasks scheduled. Multiple task names can be passed
    // 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; 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);
          }
        }
      }

      if (this._taskSequence.length === 0) {
        _throwException('Audit.run:: no task to run.');
        return;
      }

      for (let taskIndex in this._taskSequence) {
        let task = this._tasks[this._taskSequence[taskIndex]];
        // Some tests assume that tasks run in sequence, which is provided by
        // promise_test().
        promise_test((t) => task.run(t), `Executing "${task.label}"`);
      }

      // Schedule a summary report on completion.
      promise_test(() => this._finish(), "Audit report");

      // From testharness.js. The harness now need not wait for more subtests
      // to be added.
      _testharnessDone();
    }
  }

  /**
   * Load file from a given URL and pass ArrayBuffer to the following promise.
   * @param  {String} fileUrl file URL.
   * @return {Promise}
   *
   * @example
   *   Audit.loadFileFromUrl('resources/my-sound.ogg').then((response) => {
   *       audioContext.decodeAudioData(response).then((audioBuffer) => {
   *           // Do something with AudioBuffer.
   *       });
   *   });
   */
  function loadFileFromUrl(fileUrl) {
    return new Promise((resolve, reject) => {
      let xhr = new XMLHttpRequest();
      xhr.open('GET', fileUrl, true);
      xhr.responseType = 'arraybuffer';

      xhr.onload = () => {
        // |status = 0| is a workaround for the run_web_test.py server. We are
        // speculating the server quits the transaction prematurely without
        // completing the request.
        if (xhr.status === 200 || xhr.status === 0) {
          resolve(xhr.response);
        } else {
          let errorMessage = 'loadFile: Request failed when loading ' +
              fileUrl + '. ' + xhr.statusText + '. (status = ' + xhr.status +
              ')';
          if (reject) {
            reject(errorMessage);
          } else {
            new Error(errorMessage);
          }
        }
      };

      xhr.onerror = (event) => {
        let errorMessage =
            'loadFile: Network failure when loading ' + fileUrl + '.';
        if (reject) {
          reject(errorMessage);
        } else {
          new Error(errorMessage);
        }
      };

      xhr.send();
    });
  }

  /**
   * @class Audit
   * @description A WebAudio layout test task manager.
   * @example
   *   let audit = Audit.createTaskRunner();
   *   audit.define('first-task', function (task, should) {
   *     should(someValue).beEqualTo(someValue);
   *     task.done();
   *   });
   *   audit.run();
   */
  return {

    /**
     * Creates an instance of Audit task runner.
     * @param {Object}  options                     Options for task runner.
     * @param {Boolean} options.requireResultFile   True if the test suite
     *                                              requires explicit text
     *                                              comparison with the expected
     *                                              result file.
     */
    createTaskRunner: function(options) {
      if (options && options.requireResultFile == true) {
        _logError(
            'this test requires the explicit comparison with the ' +
            'expected result when it runs with run_web_tests.py.');
      }

      return new TaskRunner();
    },

    /**
     * Load file from a given URL and pass ArrayBuffer to the following promise.
     * See |loadFileFromUrl| method for the detail.
     */
    loadFileFromUrl: loadFileFromUrl

  };

})();