Convert BiquadFilter response tests to testharness

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

 // Globals, to make testing and debugging easier.
 var context;
 var filter;
 var signal;
 var renderedBuffer;
 var renderedData;
 
 var sampleRate = 44100.0;
 var pulseLengthFrames = .1 * sampleRate;
 
@@ skipping 58 matching lines @@
         filter[k].detune.value = (filterParameters[k].detune === undefined) ? 0 : filterParameters[k].detune;
         filter[k].Q.value = filterParameters[k].q;
         filter[k].gain.value = filterParameters[k].gain;
 
         signal[k].connect(filter[k]);
         filter[k].connect(context.destination);
 
         signal[k].start(timeStep * k);
     }
 
-    context.oncomplete = checkFilterResponse(filterType, testParameters);
-    context.startRendering();
+    return context.startRendering()
+        .then(buffer => {
+            checkFilterResponse(filterType, testParameters)(buffer);

[hongchan, 2017/02/01 18:18:47]

This looks a bit off. I know it's a valid expression, but can we some how fix
this?

[Raymond Toy, 2017/02/01 19:08:53]

Yeah, this can be fixed. I was going for minimal changes, but the fix is also
small.

+        });
 }
 
 function addSignal(dest, src, destOffset) {
     // Add src to dest at the given dest offset.
     for (var k = destOffset, j = 0; k < dest.length, j < src.length; ++k, ++j) {
         dest[k] += src[j];
     }
 }
 
 function generateReference(filterType, filterParameters) {
@@ skipping 19 matching lines @@
         var y = filterData(filterCoef, data, renderLengthSamples);
 
         // Accumulate this filtered data into the final output at the desired offset.
         addSignal(result, y, timeToSampleFrame(timeStep * k, sampleRate));
     }
 
     return result;
 }
 
 function checkFilterResponse(filterType, testParameters) {
-    return function(event) {
+    return function(renderedBuffer) {
         var filterParameters = testParameters.filterParameters;
         var maxAllowedError = testParameters.threshold;
-        renderedBuffer = event.renderedBuffer;
+        let should = testParameters.should;
+
         renderedData = renderedBuffer.getChannelData(0);
 
         reference = generateReference(filterType, filterParameters);
         
         var len = Math.min(renderedData.length, reference.length);
 
         var success = true;
 
         // Maximum error between rendered data and expected data
         var maxError = 0;
 
         // Sample offset where the maximum error occurred.
         var maxPosition = 0;
 
         // Number of infinities or NaNs that occurred in the rendered data.
         var invalidNumberCount = 0;
 
-        if (nFilters != filterParameters.length) {
-            testFailed("Test wanted " + filterParameters.length + " filters but only " + maxFilters + " allowed.");
-            success = false;
-        }
+        should(nFilters, "Number of filters tested")
+            .beEqualTo(filterParameters.length);
 
         // Compare the rendered signal with our reference, keeping
         // track of the maximum difference (and the offset of the max
         // difference.)  Check for bad numbers in the rendered output
         // too.  There shouldn't be any.
         for (var k = 0; k < len; ++k) {
             var err = Math.abs(renderedData[k] - reference[k]);
             if (err > maxError) {
                 maxError = err;
                 maxPosition = k;
             }
             if (!isValidNumber(renderedData[k])) {
                 ++invalidNumberCount;
             }
         }
 
-        if (invalidNumberCount > 0) {
-            testFailed("Rendered output has " + invalidNumberCount + " infinities or NaNs.");
-            success = false;
-        } else {
-            testPassed("Rendered output did not have infinities or NaNs.");
-        }
-        
-        if (maxError <= maxAllowedError) {
-            testPassed(filterTypeName[filterType] + " response is correct.");
-        } else {
-            testFailed(filterTypeName[filterType] + " response is incorrect.  Max err = " + maxError + " at " + maxPosition + ".  Threshold = " + maxAllowedError);
-            success = false;
-        }
-        
-        if (success) {
-            testPassed("Test signal was correctly filtered.");
-        } else {
-            testFailed("Test signal was not correctly filtered.");
-        }
-        finishJSTest();
+        should(invalidNumberCount,
+               "Number of non-finite values in the rendered output")
+            .beEqualTo(0);
+
+        should(maxError,
+               "Max error in " + filterTypeName[filterType] + " response")
+            .beLessThanOrEqualTo(maxAllowedError);
     }
 }