Convert Panner distance model tests to testharness

third_party/WebKit/LayoutTests/webaudio/resources/distance-model-testing.js

 var sampleRate = 44100.0;
 
 // How many panner nodes to create for the test.
 var nodesToCreate = 100;
 
 // Time step when each panner node starts.
 var timeStep = 0.001;
 
 // Make sure we render long enough to get all of our nodes.
 var renderLengthSeconds = timeStep * (nodesToCreate + 1);
@@ skipping 83 matching lines @@
         bufferSource[k].connect(panner[k]);
         panner[k].connect(context.destination);
 
         time[k] = k * timeStep;
         bufferSource[k].start(time[k]);
     }
 }
 
 // distanceModel should be the distance model string like
 // "linear", "inverse", or "exponential".
-function createTestAndRun(context, distanceModel) {
+function createTestAndRun(context, distanceModel, should) {
     // To test the distance models, we create a number of panners at
     // uniformly spaced intervals on the z-axis.  Each of these are
     // started at equally spaced time intervals.  After rendering the
     // signals, we examine where each impulse is located and the
     // attenuation of the impulse.  The attenuation is compared
     // against our expected attenuation.
 
     createGraph(context, distanceModel, nodesToCreate);
 
-    context.oncomplete = checkDistanceResult(distanceModel);
-    context.startRendering();
+    return context.startRendering()
+        .then(buffer => checkDistanceResult(buffer, distanceModel, should));
 }
 
 // The gain caused by the EQUALPOWER panning model, if we stay on the
 // z axis, with the default orientations.
 function equalPowerGain() {
     return Math.SQRT1_2;
 }
 
-function checkDistanceResult(model) {
-    return function(event) {
-        renderedBuffer = event.renderedBuffer;
-        renderedData = renderedBuffer.getChannelData(0);
+function checkDistanceResult(renderedBuffer, model, should) {
+    renderedData = renderedBuffer.getChannelData(0);
 
-        // The max allowed error between the actual gain and the expected
-        // value.  This is determined experimentally.  Set to 0 to see what
-        // the actual errors are.
-        var maxAllowedError = 3.3e-6;
+    // The max allowed error between the actual gain and the expected
+    // value.  This is determined experimentally.  Set to 0 to see
+    // what the actual errors are.
+    var maxAllowedError = 3.3e-6;
    
-        var success = true;
+    var success = true;
 
-        // Number of impulses we found in the rendered result.
-        var impulseCount = 0;
+    // Number of impulses we found in the rendered result.
+    var impulseCount = 0;
 
-        // Maximum relative error in the gain of the impulses.
-        var maxError = 0;
+    // Maximum relative error in the gain of the impulses.
+    var maxError = 0;
 
-        // Array of locations of the impulses that were not at the
-        // expected location.  (Contains the actual and expected frame
-        // of the impulse.)
-        var impulsePositionErrors = new Array();
+    // Array of locations of the impulses that were not at the
+    // expected location.  (Contains the actual and expected frame
+    // of the impulse.)
+    var impulsePositionErrors = new Array();
 
-        // Step through the rendered data to find all the non-zero points
-        // so we can find where our distance-attenuated impulses are.
-        // These are tested against the expected attenuations at that
-        // distance.
-        for (var k = 0; k < renderedData.length; ++k) {
-            if (renderedData[k] != 0) {
-                // Convert from string to index.
-                var distanceFunction = distanceModelFunction[model];
-                var expected = distanceFunction(panner[impulseCount], 0, 0, position[impulseCount]);
+    // Step through the rendered data to find all the non-zero points
+    // so we can find where our distance-attenuated impulses are.
+    // These are tested against the expected attenuations at that
+    // distance.
+    for (var k = 0; k < renderedData.length; ++k) {
+        if (renderedData[k] != 0) {
+            // Convert from string to index.
+            var distanceFunction = distanceModelFunction[model];
+            var expected = distanceFunction(panner[impulseCount], 0, 0,
+                position[impulseCount]);

[hongchan, 2017/02/21 17:14:20]

Is this the result from clang-format? If so, I am really sad.

[Raymond Toy, 2017/02/21 17:38:38]

No, it's not clang-format which would have changed the indentation to 2 spaces
instead of 4. I didn't want to reindent everything to 2 spaces in this CL.

[hongchan, 2017/02/22 18:51:06]

No. I wasn't talking about the indentation. It should be like this:

var expected = 
   distanceFunction(panner[impulseCount], 0, 0, position[impulseCount]);

Just like what we do long arguments in chromium code.

[Raymond Toy, 2017/02/22 19:02:20]

Done.

 
-                // Adjust for the center-panning of the EQUALPOWER panning
-                // model that we're using.
-                expected *= equalPowerGain();
+            // Adjust for the center-panning of the EQUALPOWER panning
+            // model that we're using.
+            expected *= equalPowerGain();
 
-                var error = Math.abs(renderedData[k] - expected) / Math.abs(expected);
+            var error = Math.abs(renderedData[k] - expected) / Math.abs(
+                expected);

[hongchan, 2017/02/21 17:14:20]

Ditto.

[Raymond Toy, 2017/02/21 17:38:38]

Same.

[hongchan, 2017/02/22 18:51:06]

The argument of Math.abs is in the next line.

[Raymond Toy, 2017/02/22 19:02:20]

Done.

 
-                maxError = Math.max(maxError, Math.abs(error));
+            maxError = Math.max(maxError, Math.abs(error));
 
-                // Keep track of any impulses that aren't where we expect them
-                // to be.
-                var expectedOffset = timeToSampleFrame(time[impulseCount], sampleRate);
-                if (k != expectedOffset) {
-                    impulsePositionErrors.push({ actual : k, expected : expectedOffset});
-                }
-                ++impulseCount;
+            // Keep track of any impulses that aren't where we expect them
+            // to be.
+            var expectedOffset = timeToSampleFrame(time[impulseCount],
+                sampleRate);
+            if (k != expectedOffset) {
+                impulsePositionErrors.push({
+                    actual: k,
+                    expected: expectedOffset
+                });
             }
+            ++impulseCount;
         }
+    }
+    should(impulseCount, "Number of impulses")
+        .beEqualTo(nodesToCreate);
 
-        if (impulseCount == nodesToCreate) {
-            testPassed("Number of impulses found matches number of panner nodes.");
-        } else {
-            testFailed("Number of impulses is incorrect.  Found " + impulseCount + " but expected " + nodesToCreate + ".");
-            success = false;
-        }
+    should(maxError, "Max error in distance gains")
+        .beLessThanOrEqualTo(maxAllowedError);
 
-        if (maxError <= maxAllowedError) {
-            testPassed("Distance gains are correct.");
-        } else {
-            testFailed("Distance gains are incorrect.  Max rel error = " + maxError + " (maxAllowedError = " + maxAllowedError + ")");
-            success = false;
-        }
-
-        // Display any timing errors that we found.
-        if (impulsePositionErrors.length > 0) {
-            success = false;
-            testFailed(impulsePositionErrors.length + " timing errors found");
-            for (var k = 0; k < impulsePositionErrors.length; ++k) {
-                testFailed("Sample at frame " + impulsePositionErrors[k].actual + " but expected " + impulsePositionErrors[k].expected);
-            }
-        }
-
-        if (success) {
-            testPassed("Distance test passed for distance model " + model);
-        } else {
-            testFailed("Distance test failed for distance model " + model);
-        }
-
-        finishJSTest();
+    // Display any timing errors that we found.
+    if (impulsePositionErrors.length > 0) {
+        let actual = impulsePositionErrors.map(x => x.actual);
+        let expected = impulsePositionErrors.map(x => x.expected);
+        should(actual, "Actual impulse positions found")
+            .beEqualToArray(expected);
     }
 }