// 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;
// debugger;
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
};
})();
Codebase Browser
chromium