Use interpolation for setValueCurveAtTime

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 343 matching lines @@
     for (var i = 1; i <= numChannels; i++) {
         var data = buffer.getChannelData(i-1);
         for (var j = 0; j < data.length; j++) {
             // Storing channel index into the channel buffer.
             data[j] = i;
         }
     }
     return buffer;
 }
 
+// Compute the (linear) signal-to-noise ratio between |actual| and |expected|.  The result is NOT in
+// dB!  If the |actual| and |expected| have different lengths, the shorter length is used.
+function computeSNR(actual, expected)
+{
+    var signalPower = 0;
+    var noisePower = 0;
+
+    var length = Math.min(actual.length, expected.length);
+
+    for (var k = 0; k < length; ++k) {
+        var diff = actual[k] - expected[k];
+        signalPower += expected[k] * expected[k];
+        noisePower += diff * diff;
+    }
+
+    return signalPower / noisePower;
+}
 
 // |Should| JS layout test utility.
 // Dependency: ../resources/js-test.js
 var Should = (function () {
 
     'use strict';
 
     // ShouldModel internal class. For the exposed (factory) method, it is the
     // return value of this closure.
     function ShouldModel(desc, target, opts) {
         this.desc = desc;
         this.target = target;
+        // |_testPassed| and |_testFailed| set this appropriately.
+        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;
     }
 
     // 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) {
         if (expression)
             return;
 
@@ skipping 10 matching lines @@
     // "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');
 
         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');
 
         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).greaterThanOrEqualTo(100);
+    // 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');
 
         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');
+
+        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.
     //
     // 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) {
         var type = typeof value;
         this._assert(type === 'number', 'value should be number for');
 
         var relativeError = Math.abs(this.target - value) / Math.abs(value);
         if (relativeError <= relativeErrorThreshold) {
             this._testPassed("is " + value + " within a relative error of " + relativeErrorThreshold);
         } else {
             this._testFailed("is not " + value + " within a relative error of " + relativeErrorThreshold
                              + ": " + this.target);
         }
+        return this._success;
     }
 
     // Check if |func| throws an exception with a certain |errorType| correctly.
     // |errorType| is optional.
     //
     // Example:
     // Should('A bad code', function () { var a = b; }).throw();
     // Result:
     // "PASS A bad code threw an exception."
     // Example:
     // Should('var c = d', function () { var c = d; }).throw('ReferenceError');
     // "PASS var c = d threw ReferenceError."
     ShouldModel.prototype.throw = function (errorType) {
         if (typeof this.target !== 'function') {
             console.log('target is not a function. test halted.');
             return;
         }
 
         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);
         }
+        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."
     ShouldModel.prototype.notThrow = function () {
         try {
             this.target();
             this._testPassed('did not throw an exception');
         } catch (error) {
             this._testFailed('threw ' + error.name + ': ' + error.message);
         }
+        return this._success;
     };
 
     // Check if |target| array is filled with constant values.
     //
     // Example:
     // Should('[2, 2, 2]', [2, 2, 2]).beConstantValueOf(2);
     // Result:
     // "PASS [2, 2, 2] has constant values of 2."
     ShouldModel.prototype.beConstantValueOf = function (value) {
         var mismatches = {};
@@ skipping 13 matching lines @@
             for (var index in mismatches) {
                 failureMessage += '\n[' + index + '] : ' + mismatches[index];
                 if (++counter >= this.NUM_ERRORS_LOG) {
                     failureMessage += '\nand ' + (numberOfmismatches - counter) +
                     ' more differences...';
                     break;
                 }
             }
             this._testFailed(failureMessage);
         }
+        return this._success;
     };
 
     // 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,
@@ skipping 18 matching lines @@
                 failureMessage += '\n[' + index + '] : ' + mismatches[index];
                 if (++counter >= this.NUM_ERRORS_LOG) {
                     failureMessage += '\nand ' + (numberOfmismatches - counter) +
                     ' more differences...';
                     break;
                 }
             }
 
             this._testFailed(failureMessage);
         }
+        return this._success;
     };
 
     // Check if |target| array is close to |expected| array element-wise within
     // the range of |maxAllowedError|.
     //
     // 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) {
@@ skipping 24 matching lines @@
                 failureMessage += '\n[' + index + '] : ' + mismatches[index];
                 if (++counter >= this.NUM_ERRORS_LOG) {
                     failureMessage += '\nand ' + (numberOfmismatches - counter) +
                     ' more differences...';
                     break;
                 }
             }
 
             this._testFailed(failureMessage);
         }
+        return this._success;
     };
 
     // Check if |target| array contains a set of values in a certain order.
     //
     // Example:
     // Should('My random array', [1, 1, 3, 3, 2]).containValues([1, 3, 2]);
     // Result:
     // "PASS My random array contains all the expected values in the correct
     //  order: [1,3,2]."
     ShouldModel.prototype.containValues = function (expected) {
         var indexExpected = 0, indexActual = 0;
         while (indexExpected < expected.length && indexActual < this.target.length) {
             if (expected[indexExpected] === this.target[indexActual])
                 indexActual++;
             else
                 indexExpected++;
         }
 
         if (indexExpected < expected.length-1 || indexActual < this.target.length-1) {
             this._testFailed('contains an unexpected value ' + this.target[indexActual] +
             ' at index ' + indexActual);
         } else {
             this._testPassed('contains all the expected values in the correct order: [' +
             expected + ']');
         }
+        return this._success;
     };
 
     // Check if |target| array does not have any glitches. Note that |threshold|
     // is not optional and is to define the desired threshold value.
     //
     // Example:
     // Should('Channel #0', chanL).notGlitch(0.0005);
     // Result:
     // "PASS Channel #0 has no glitch above the threshold of 0.0005."
     ShouldModel.prototype.notGlitch = function (threshold) {
         for (var i = 1; i < this.target.length; i++) {
             var diff = Math.abs(this.target[i-1] - this.target[i]);
             if (diff >= threshold) {
                 this._testFailed('has a glitch at index ' + i + ' of size ' + diff);
-                return;
+                return this._success;
             }
         }
         this._testPassed('has no glitch above the threshold of ' + threshold);
+        return this._success;
     };
 
     // Should() method.
     //
     // |desc| is the description of the task or check and |target| is a value
     // needs to be checked or a task to be performed. |opt| contains options for
     // printing out log messages: options are |opt.numberOfErrorLog| and
     // |opts.numberOfArrayLog|.
     return function (desc, target, opts) {
         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;
         }
 
         return new ShouldModel(desc, target, _opts);
     };
 
 })();