Implement IIRFilter node for WebAudio.

third_party/WebKit/LayoutTests/webaudio/resources/audio-testing.js

 function writeString(s, a, offset) {
     for (var i = 0; i < s.length; ++i) {
         a[offset + i] = s.charCodeAt(i);
     }
 }
 
 function writeInt16(n, a, offset) {
     n = Math.floor(n);
 
     var b1 = n & 255;
@@ skipping 389 matching lines @@
         this._success = false;
 
         // If the number of errors is greater than this, the rest of error
         // messages are suppressed. the value is fairly arbitrary, but shouldn't
         // be too small or too large.
         this.NUM_ERRORS_LOG = opts.numberOfErrorLog;
 
         // If the number of array elements is greater than this, the rest of
         // elements will be omitted.
         this.NUM_ARRAY_LOG = opts.numberOfArrayLog;
+
+        // If true, verbose output for the failure case is printed, for methods where this makes
+        // sense.
+        this.verbose = opts.verbose;
+
+        // If set, this is the precision with which numbers will be printed.
+        this.PRINT_PRECISION = opts.precision;
     }
 
     // Internal methods starting with a underscore.
     ShouldModel.prototype._testPassed = function (msg) {
         testPassed(this.desc + ' ' + msg + '.');
         this._success = true;
     };
 
     ShouldModel.prototype._testFailed = function (msg) {
         testFailed(this.desc + ' ' + msg + '.');
         this._success = false;
     };
 
     ShouldModel.prototype._isArray = function (arg) {
         return arg instanceof Array || arg instanceof Float32Array;
     };
 
-    ShouldModel.prototype._assert = function (expression, reason) {
+    ShouldModel.prototype._assert = function (expression, reason, value) {
         if (expression)
             return;
 
         var failureMessage = 'Assertion failed: ' + reason + ' ' + this.desc +'.';
+        if (arguments.length >= 3)
+            failureMessage += ": " + value;
         testFailed(failureMessage);
         throw failureMessage;
     };
 
     // Check if |target| is equal to |value|.
     //
     // Example:
     // Should('Zero', 0).beEqualTo(0);
     // Result:
     // "PASS Zero is equal to 0."
     ShouldModel.prototype.beEqualTo = function (value) {
         var type = typeof value;
         this._assert(type === 'number' || type === 'string',
-            'value should be number or string for');
+            'value should be number or string for', value);
 
         if (this.target === value)
             this._testPassed('is equal to ' + value);
         else
             this._testFailed('was ' + this.target + ' instead of ' + value);
         return this._success;
     };
 
     // Check if |target| is not equal to |value|.
     //
     // Example:
     // Should('One', one).notBeEqualTo(0);
     // Result:
     // "PASS One is not equal to 0."
     ShouldModel.prototype.notBeEqualTo = function (value) {
         var type = typeof value;
         this._assert(type === 'number' || type === 'string',
-            'value should be number or string for');
+            'value should be number or string for', value);
 
         if (this.target === value)
             this._testFailed('should not be equal to ' + value);
         else
             this._testPassed('is not equal to ' + value);
         return this._success;
     };
 
     // Check if |target| is greater than or equal to |value|.
     //
     // Example:
     // Should("SNR", snr).beGreaterThanOrEqualTo(100);
     // Result:
     // "PASS SNR exceeds 100"
     // "FAIL SNR (n) is not greater than or equal to 100"
     ShouldModel.prototype.beGreaterThanOrEqualTo = function (value) {
         var type = typeof value;
         this._assert(type === 'number' || type === 'string',
-            'value should be number or string for');
+            'value should be number or string for', value);
 
         if (this.target >= value)
             this._testPassed("is greater than or equal to " + value);
         else
             this._testFailed("(" + this.target + ") is not greater than or equal to " + value);
         return this._success;
     }
 
     // Check if |target| is lest than or equal to |value|.
     //
     // Example:
     // maxError = 1e-6;
     // Should("max error", maxError).beLessThanOrEqualTo(1e-5);
     // Should("max error", maxError).beLessThanOrEqualTo(-1);
     // Result:
     // "PASS max error is less than or equal to 1e-5"
     // "FAIL max error (1e-6) is not less than or equal to -1"
     ShouldModel.prototype.beLessThanOrEqualTo = function (value) {
         var type = typeof value;
-        this._assert(type === 'number', 'value should be number or string for');
+        this._assert(type === 'number', 'value should be number or string for', value);
 
         if (this.target <= value)
             this._testPassed("is less than or equal to " + value);
         else
             this._testFailed("(" + this.target + ") is not less than or equal to " + value);
         return this._success;
     }
 
     // Check if |target| is close to |value| using the given relative error |threshold|.  |value|
     // should not be zero, but no check is made for that.  The |target| value is printed to
     // precision |precision|, with |precision| defaulting to 7.
     //
     // If |value| is 0, however, |threshold| is treated as an absolute threshold.
     //
     // Example:
     // Should("One", 1.001).beCloseTo(1, .1);
     // Should("One", 2).beCloseTo(1, .1);
     // Result:
     // "PASS One is 1 within a relative error of 0.1."
     // "FAIL One is not 1 within a relative error of 0.1: 2"
     ShouldModel.prototype.beCloseTo = function (value, errorThreshold, precision) {
         var type = typeof value;
-        this._assert(type === 'number', 'value should be number for');
+        this._assert(type === 'number', 'value should be number for', value);
 
         if (value) {
             var relativeError = Math.abs(this.target - value) / Math.abs(value);
             if (relativeError <= errorThreshold) {
                 this._testPassed("is " + value.toPrecision(precision) +
                     " within a relative error of " + errorThreshold);
             } else {
                 // Include actual relative error so the failed test case can be updated with the actual
                 // relative error, if appropriate.
                 this._testFailed("is not " + value.toPrecision(precision) +
@@ skipping 38 matching lines @@
             this.target();
             this._testFailed('did not throw an exception');
         } catch (error) {
             if (errorType === undefined)
                 this._testPassed('threw an exception of type ' + error.name);
             else if (error.name === errorType)
                 this._testPassed('threw ' + errorType + ': ' + error.message);
             else if (self.hasOwnProperty(errorType) && error instanceof self[errorType])
                 this._testPassed('threw ' + errorType + ': ' + error.message);
             else
-                this._testFailed('threw ' + error.name + ' instead of ' + exception);
+                this._testFailed('threw ' + error.name + ' instead of ' + errorType);
         }
         return this._success;
     };
 
     // Check if |func| does not throw an exception.
     //
     // Example:
     // Should('var foo = "bar"', function () { var foo = 'bar'; }).notThrow();
     // Result:
     // "PASS var foo = "bar" did not throw an exception."
@@ skipping 42 matching lines @@
     };
 
     // Check if |target| array is identical to |expected| array element-wise.
     //
     // Example:
     // Should('[1, 2, 3]', [1, 2, 3]).beEqualToArray([1, 2, 3]);
     // Result:
     // "PASS [1, 2, 3] is identical to the array [1,2,3]."
     ShouldModel.prototype.beEqualToArray = function (array) {
         this._assert(this._isArray(array) && this.target.length === array.length,
-            'Invalid array or the length does not match.');
+            'Invalid array or the length does not match.', array);
 
         var mismatches = {};
         for (var i = 0; i < this.target.length; i++) {
             if (this.target[i] !== array[i])
                 mismatches[i] = this.target[i];
         }
 
         var numberOfmismatches = Object.keys(mismatches).length;
         var arrStr = (array.length > this.NUM_ARRAY_LOG) ?
         array.slice(0, this.NUM_ARRAY_LOG).toString() + '...' : array.toString();
@@ skipping 11 matching lines @@
                     break;
                 }
             }
 
             this._testFailed(failureMessage);
         }
         return this._success;
     };
 
     // Check if |target| array is close to |expected| array element-wise within
-    // the range of |maxAllowedError|.
+    // an certain error bound given by |absoluteThresholdOrOptions|.
+    //
+    // The error criterion is:
+    //
+    //   Math.abs(target[k] - expected[k]) < Math.max(abserr, relerr * Math.abs(expected))
+    //
+    // If |absoluteThresholdOrOptions| is a number, t, then abserr = t and relerr = 0.  That is the
+    // max difference is bounded by t.
+    //
+    // If |absoluteThresholdOrOptions| is a property bag, then abserr is the value of the
+    // absoluteThreshold property and relerr is the value of the relativeThreshold property.  If
+    // nothing is given, 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.
     //
     // Example:
     // Should('My array', [0.11, 0.19]).beCloseToArray([0.1, 0.2], 0.02);
     // Result:
     // "PASS My array equals [0.1,0.2] within an element-wise tolerance of 0.02."
-    ShouldModel.prototype.beCloseToArray = function (array, maxAllowedError) {
+    ShouldModel.prototype.beCloseToArray = function (expected, absoluteThresholdOrOptions) {
         // For the comparison, the target length must be bigger than the expected.
-        this._assert(this.target.length >= array.length,
-            'The target array length must be longer than ' + array.length +
+        this._assert(this.target.length >= expected.length,
+            'The target array length must be longer than ' + expected.length +
             ' but got ' + this.target.length + '.');
 
+        var absoluteErrorThreshold = 0;
+        var relativeErrorThreshold = 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.
         var mismatches = {};
-        var maxDiff = 0.0;
-        var maxDiffIndex = 0;
-        for (var i = 0; i < array.length; i++) {
-            var diff = Math.abs(this.target[i] - array[i]);
-            if (diff > maxAllowedError)
+
+        // Keep track of the max absolute error found
+        var maxAbsError = -Infinity;
+        var maxAbsErrorIndex = -1;
+        // Keep trac of the max relative error found, ignoring cases where the relative error is
+        // Infinity because the expected value is 0.
+        var maxRelError = -Infinity;
+        var maxRelErrorIndex = -1;
+
+        // A number or string for printing out the actual thresholds used for the error criterion.
+        var maxAllowedError;
+
+        // Set up the thresholds based on |absoluteThresholdOrOptions|.
+        if (typeof(absoluteThresholdOrOptions) === 'number') {
+            absoluteErrorThreshold = absoluteThresholdOrOptions;
+            maxAllowedError = absoluteErrorThreshold;
+        } else {
+            var opts = absoluteThresholdOrOptions;
+            if (opts.hasOwnProperty('absoluteThreshold'))
+                absoluteErrorThreshold = opts.absoluteThreshold;
+            if (opts.hasOwnProperty('relativeThreshold'))
+                relativeErrorThreshold = opts.relativeThreshold;
+            maxAllowedError = '{absoluteThreshold: ' + absoluteErrorThreshold
+              + ', relativeThreshold: ' + relativeErrorThreshold
+              + '}';
+        }
+
+        for (var i = 0; i < expected.length; i++) {
+            var diff = Math.abs(this.target[i] - expected[i]);
+            if (diff > Math.max(absoluteErrorThreshold, relativeErrorThreshold * Math.abs(expected[i]))) {
                 mismatches[i] = diff;
-            if (diff > maxDiff) {
-                maxDiff = diff;
-                maxDiffIndex = i;
+                // Keep track of the location of the absolute max difference.
+                if (diff > maxAbsError) {
+                    maxAbsErrorIndex = i;
+                    maxAbsError = diff;
+                }
+                // Keep track of the location of the max relative error, ignoring cases where the
+                // relative error is ininfinity (because the expected value = 0).
+                var relError = diff / Math.abs(expected[i]);
+                if (isFinite(relError) && relError > maxRelError) {
+                    maxRelErrorIndex = i;
+                    maxRelError = relError;
+                }
             }
         }
 
         var numberOfmismatches = Object.keys(mismatches).length;
-        var arrStr = (array.length > this.NUM_ARRAY_LOG) ?
-        array.slice(0, this.NUM_ARRAY_LOG).toString() + ',...' : array.toString();
+        var arrSlice = expected.slice(0, Math.min(expected.length, this.NUM_ARRAY_LOG));
+        var arrStr;
 
+        arrStr = arrSlice[0].toPrecision(this.PRINT_PRECISION);
+        for (var k = 1; k < arrSlice.length; ++k)
+            arrStr += ',' + arrSlice[k].toPrecision(this.PRINT_PRECISION);
+
+        if (expected.length > this.NUM_ARRAY_LOG)
+            arrStr += ',...';
         if (numberOfmismatches === 0) {
             this._testPassed('equals [' + arrStr +
                 '] with an element-wise tolerance of ' + maxAllowedError);
         } else {
             var counter = 0;
             var failureMessage = 'does not equal [' + arrStr +
                 '] with an element-wise tolerance of ' + maxAllowedError;
-            failureMessage += '\nIndex\t    Diff\t\t    Actual\t\t    Expected';
+
+            // Print a nice header for the  table to follow.
+            if (this.verbose)
+                failureMessage += "\nIndex     Actual                  Expected                Diff                   Relative";
+            else
+                failureMessage += "\nDifference between expected and actual:";
+
             for (var index in mismatches) {
-                failureMessage += '\n[' + index + '] :\t' + mismatches[index] +
-                    '\t' + this.target[index] + '\t' + array[index];
-                if (++counter >= this.NUM_ERRORS_LOG || counter === numberOfmismatches) {
+                failureMessage += '\n[' + index + ']:    ';
+                if (this.verbose) {
+                    // When verbose, print out actual, expected, absolute error, and relative error.
+                    // TODO: print these out in nice columns to make it easier to read.
+                    var relError = Math.abs(this.target[index] - expected[index]) / Math.abs(expected[index]);
+                    failureMessage += this.target[index].toExponential(16) + '   '
+                            + expected[index].toExponential(16) + '   '
+                            + mismatches[index].toExponential(16) + '  '
+                            + relError.toExponential(16) + '  '
+                            + Math.max(absoluteErrorThreshold,
+                                       relativeErrorThreshold * Math.abs(expected[index]));
+                } else {
+                    // Otherwise, just the print the absolute error.
+                    failureMessage += mismatches[index];
+                }
+                if (++counter >= this.NUM_ERRORS_LOG) {
                     failureMessage += '\nand ' + (numberOfmismatches - counter) +
-                        ' more differences with the maximum error of ' + maxDiff +
-                        ' at index ' + maxDiffIndex;
+                            ' more differences, with max absolute error';
+                    if (this.verbose) {
+                        // When verbose, print out the location of both the max absolute error and
+                        // the max relative error so we can adjust thresholds appropriately in the
+                        // test.
+                        var relError = Math.abs(this.target[maxAbsErrorIndex] - expected[maxAbsErrorIndex])
+                                / Math.abs(expected[maxAbsErrorIndex]);
+                        failureMessage += ' at index ' + maxAbsErrorIndex + ':';
+                        failureMessage += '\n[' + maxAbsErrorIndex + ']:    ';
+                        failureMessage += this.target[maxAbsErrorIndex].toExponential(16) + '   '
+                                + expected[maxAbsErrorIndex].toExponential(16) + '   '
+                                + mismatches[maxAbsErrorIndex].toExponential(16) + '   '
+                                + relError.toExponential(16) + '  '
+                                + Math.max(absoluteErrorThreshold,
+                                    relativeErrorThreshold * Math.abs(expected[maxAbsErrorIndex]));
+                        failureMessage += '\nand max relative error';
+                        failureMessage += ' at index ' + maxRelErrorIndex + ':';
+                        failureMessage += '\n[' + maxRelErrorIndex + ']:    ';
+                        failureMessage += this.target[maxRelErrorIndex].toExponential(16) + '   '
+                                + expected[maxRelErrorIndex].toExponential(16) + '   '
+                                + mismatches[maxRelErrorIndex].toExponential(16) + '   '
+                                + maxRelError.toExponential(16) + '  '
+                                + Math.max(absoluteErrorThreshold,
+                                    relativeErrorThreshold * Math.abs(expected[maxRelErrorIndex]));
+                    } else {
+                        // Not verbose, so just print out the max absolute error
+                        failureMessage += ' of ' + maxAbsError + ' at index ' + maxAbsErrorIndex;
+                    }
                     break;
                 }
             }
 
             this._testFailed(failureMessage);
         }
         return this._success;
     };
 
     // Check if |target| array contains a set of values in a certain order.
@@ skipping 81 matching lines @@
         var _opts = {
             numberOfErrorLog: 8,
             numberOfArrayLog: 16
         };
 
         if (opts instanceof Object) {
             if (opts.hasOwnProperty('numberOfErrorLog'))
                 _opts.numberOfErrorLog = opts.numberOfErrorLog;
             if (opts.hasOwnProperty('numberOfArrayLog'))
                 _opts.numberOfArrayLog = opts.numberOfArrayLog;
+            if (opts.hasOwnProperty('verbose'))
+                _opts.verbose = opts.verbose;
+            if (opts.hasOwnProperty('precision'))
+                _opts.precision = opts.precision;
         }
 
         return new ShouldModel(desc, target, _opts);
     };
 
 })();