Implement IIRFilter node for WebAudio.

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

 if (window.testRunner)
     testRunner.overridePreference("WebKitWebAudioEnabled", "1");
 
 function writeString(s, a, offset) {
     for (var i = 0; i < s.length; ++i) {
         a[offset + i] = s.charCodeAt(i);
     }
 }
 
 function writeInt16(n, a, offset) {
@@ skipping 425 matching lines @@
 
     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 ' + value + ' instead of ' + this.target);
         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.
     //
     // 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, relativeErrorThreshold, precision) {
         var type = typeof value;
-        this._assert(type === 'number', 'value should be number for');
+        this._assert(type === 'number', 'value should be number for', value);
 
         var relativeError = Math.abs(this.target - value) / Math.abs(value);
         if (relativeError <= relativeErrorThreshold) {
             this._testPassed("is " + value.toPrecision(precision) +
                 " within a relative error of " + relativeErrorThreshold);
         } 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) +
                 " within a relative error of " + relativeErrorThreshold +
@@ skipping 21 matching lines @@
 
         try {
             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
-                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 24 matching lines @@
     // 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) {
         // 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 +
             ' but got ' + this.target.length + '.');
 
         var mismatches = {};
+        var maxError = -Infinity;
+        var maxErrorIndex = -1;
         for (var i = 0; i < array.length; i++) {
             var diff = Math.abs(this.target[i] - array[i]);
-            if (diff > maxAllowedError)
+            if (diff > maxAllowedError) {
                 mismatches[i] = diff;
+                if (diff > maxError) {
+                    maxErrorIndex = i;
+                    maxError = diff;
+                }
+            }
         }
 
         var numberOfmismatches = Object.keys(mismatches).length;
         var arrStr = (array.length > this.NUM_ARRAY_LOG) ?
         array.slice(0, this.NUM_ARRAY_LOG).toString() + ',...' : array.toString();
 
         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;
             for (var index in mismatches) {
                 failureMessage += '\n[' + index + '] : ' + mismatches[index];
                 if (++counter >= this.NUM_ERRORS_LOG) {
                     failureMessage += '\nand ' + (numberOfmismatches - counter) +
-                    ' more differences...';
+                        ' more differences with max difference of ' + maxError +
+                        ' at index ' + maxErrorIndex;
                     break;
                 }
             }
 
             this._testFailed(failureMessage);
         }
         return this._success;
     };
 
     // Check if |target| array contains a set of values in a certain order.
@@ skipping 57 matching lines @@
             if (opts.hasOwnProperty('numberOfErrorLog'))
                 _opts.numberOfErrorLog = opts.numberOfErrorLog;
             if (opts.hasOwnProperty('numberOfArrayLog'))
                 _opts.numberOfArrayLog = opts.numberOfArrayLog;
         }
 
         return new ShouldModel(desc, target, _opts);
     };
 
 })();