Convert AudioParam tests to testharness and new Audit

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

 var sampleRate = 44100;
 
 // Information about the starting/ending times and starting/ending values for each time interval.
 var timeValueInfo;
 
 // The difference between starting values between each time interval.
 var startingValueDelta;
       
 // For any automation function that has an end or target value, the end value is based the starting
 // value of the time interval.  The starting value will be increased or decreased by
@@ skipping 201 matching lines @@
 
 // Return the difference between the starting value at |timeIntervalIndex| and the starting value at
 // the next time interval.  Since we started at a large initial value, we decrease the value at each
 // time interval.
 function valueUpdate(timeIntervalIndex)
 {
     return -startingValueDelta;
 }
 
 // Compare a section of the rendered data against our expected signal.
-function comparePartialSignals(rendered, expectedFunction, startTime, endTime, valueInfo, sampleRate, errorMetric)
+function comparePartialSignals(should, rendered, expectedFunction, startTime, endTime, valueInfo, sampleRate, errorMetric)
 {
     var startSample = timeToSampleFrame(startTime, sampleRate);
     var expected = expectedFunction(startTime, endTime, valueInfo.startValue, valueInfo.endValue, sampleRate, timeConstant);
 
     var n = expected.length;
     var maxError = -1;
     var maxErrorIndex = -1;
     
     for (var k = 0; k < n; ++k) {
         // Make sure we don't pass these tests because a NaN has been generated in either the
         // rendered data or the reference data.
         if (!isValidNumber(rendered[startSample + k])) {
             maxError = Infinity;
             maxErrorIndex = startSample + k;
-            testFailed("NaN or infinity for rendered data at " + maxErrorIndex);
+            //testFailed("NaN or infinity for rendered data at " + maxErrorIndex);

[hongchan, 2017/01/30 17:38:04]

Remove this line.

+            should(!isValidNumber(rendered[startSample + k]),

[hongchan, 2017/01/30 17:38:04]

Can this be |isValidNumber()| then |beTrue()|?

Same for l.247.

[Raymond Toy, 2017/01/30 18:07:02]

I thought it would be better to keep the test condition be the same as the if in
line 234.  But I can reverse the test here if it's better.

+                   "NaN or infinity for rendered data at " + maxErrorIndex)
+                .beFalse();
             break;
         }
         if (!isValidNumber(expected[k])) {
             maxError = Infinity;
             maxErrorIndex = startSample + k;
-            testFailed("Nan or infinity for reference data at " + maxErrorIndex);
+            //testFailed("Nan or infinity for reference data at " + maxErrorIndex);

[hongchan, 2017/01/30 17:38:04]

Ditto.

+            should(!isValidNumber(expected[k]),
+                   "NaN or infinity for rendered data at " + maxErrorIndex)
+                .beFalse();
             break;
         }
         var error = Math.abs(errorMetric(rendered[startSample + k], expected[k]));
         if (error > maxError) {
             maxError = error;
             maxErrorIndex = k;
         }
     }
 
     return {maxError : maxError, index : maxErrorIndex, expected: expected};
 }
 
 // Find the discontinuities in the data and compare the locations of the discontinuities with the
 // times that define the time intervals. There is a discontinuity if the difference between
 // successive samples exceeds the threshold.
-function verifyDiscontinuities(values, times, threshold)
+function verifyDiscontinuities(should, values, times, threshold)
 {
     var n = values.length;
     var success = true;
     var badLocations = 0;
     var breaks = [];
 
     // Find discontinuities.
     for (var k = 1; k < n; ++k) {
         if (Math.abs(values[k] - values[k - 1]) > threshold) {
             breaks.push(k);
         }
     }
 
     var testCount;
 
     // If there are numberOfTests intervals, there are only numberOfTests - 1 internal interval
     // boundaries. Hence the maximum number of discontinuties we expect to find is numberOfTests -
     // 1. If we find more than that, we have no reference to compare against. We also assume that
     // the actual discontinuities are close to the expected ones.
     //
     // This is just a sanity check when something goes really wrong.  For example, if the threshold
     // is too low, every sample frame looks like a discontinuity.
     if (breaks.length >= numberOfTests) {
         testCount = numberOfTests - 1;
-        testFailed("Found more discontinuities (" + breaks.length + ") than expected.  Only comparing first " + testCount + "discontinuities.");
+        //testFailed("Found more discontinuities (" + breaks.length + ") than expected.  Only comparing first " + testCount + "discontinuities.");
+        should(breaks.length,
+               "Number of discontinuities")
+            .beLessThan(numberOfTests);
         success = false;
     } else {
         testCount = breaks.length;
     }
     
     // Compare the location of each discontinuity with the end time of each interval. (There is no
     // discontinuity at the start of the signal.)
     for (var k = 0; k < testCount; ++k) {
         var expectedSampleFrame = timeToSampleFrame(times[k + 1], sampleRate);
         if (breaks[k] != expectedSampleFrame) {
             success = false;
             ++badLocations;
-            testFailed("Expected discontinuity at " + expectedSampleFrame + " but got " + breaks[k]);
+            //testFailed("Expected discontinuity at " + expectedSampleFrame + " but got " + breaks[k]);
+            should(breaks[k],
+                   "Discontinuity at index")
+                .beEqualTo(expectedSampleFrame);
         }
     }
 
     if (badLocations) {
-        testFailed(badLocations + " discontinuities at incorrect locations");
+      //testFailed(badLocations + " discontinuities at incorrect locations");
+      should(badLocations, "Number of discontinuites at incorrect locations")
+          .beEqualTo(0);
         success = false;
     } else {
+      /*
         if (breaks.length == numberOfTests - 1) {
             testPassed("All " + numberOfTests + " tests started and ended at the correct time.");
         } else {
             testFailed("Found " + breaks.length + " discontinuities but expected " + (numberOfTests - 1));
             success = false;
         }
+      */
+      should(breaks.length + 1,
+             "Number of tests started and ended at the correct time")
+          .beEqualTo(numberOfTests);
     }
     
     return success;
 }
 
 // Compare the rendered data with the expected data.
 //
 // testName - string describing the test
 //
 // maxError - maximum allowed difference between the rendered data and the expected data
 //
 // rendererdData - array containing the rendered (actual) data
 //
 // expectedFunction - function to compute the expected data
 //
 // timeValueInfo - array containing information about the start and end times and the start and end
 // values of each interval.
 //
 // breakThreshold - threshold to use for determining discontinuities.
-function compareSignals(testName, maxError, renderedData, expectedFunction, timeValueInfo, breakThreshold, errorMetric)
+function compareSignals(should, testName, maxError, renderedData, expectedFunction, timeValueInfo, breakThreshold, errorMetric)
 {
     var success = true;
     var failedTestCount = 0;
     var times = timeValueInfo.times;
     var values = timeValueInfo.values;
     var n = values.length;
     var expectedSignal = [];
 
-    success = verifyDiscontinuities(renderedData, times, breakThreshold);
+    success = verifyDiscontinuities(should, renderedData, times, breakThreshold);
 
     for (var k = 0; k < n; ++k) {
-        var result = comparePartialSignals(renderedData, expectedFunction, times[k], times[k + 1], values[k], sampleRate, errorMetric);
+      var result = comparePartialSignals(should, renderedData, expectedFunction, times[k], times[k + 1], values[k], sampleRate, errorMetric);
 
         expectedSignal = expectedSignal.concat(Array.prototype.slice.call(result.expected));
 
+        /*

[hongchan, 2017/01/30 17:38:04]

Remove commented line.

         if (result.maxError > maxError) {
             var offset = result.index + timeToSampleFrame(times[k], sampleRate);
             testFailed("Incorrect value for test " + k + ". Max error = " + result.maxError
                        + " at offset " + offset
                        + ": actual = " + renderedData[offset]
                        + ", expected = " + expectedSignal[offset] + ".");
             ++failedTestCount;
         }
+        */
+        should(result.maxError,
+               "Max error for test " + k + " at offset " + (result.index + timeToSampleFrame(times[k], sampleRate)))
+            .beLessThanOrEqualTo(maxError);
     }
 
+    /*

[hongchan, 2017/01/30 17:38:04]

Ditto.

     if (failedTestCount) {
         testFailed(failedTestCount + " tests failed out of " + n);
         success = false;
     } else {
         testPassed("All " + n + " tests passed within an acceptable relative tolerance of " + maxError + ".");
     }
+    */
+    should(failedTestCount,
+           "Number of failed tests with an acceptable relative tolerance of " + maxError)
+        .beEqualTo(0);
       
+    /*

[hongchan, 2017/01/30 17:38:04]

Ditto.

     if (success) {
         testPassed("AudioParam " + testName + " test passed.");
     } else {
         testFailed("AudioParam " + testName + " test failed.");
     }
+    */
 }
 
 // Create a function to test the rendered data with the reference data.
 //
 // testName - string describing the test
 //
 // error - max allowed error between rendered data and the reference data.
 //
 // referenceFunction - function that generates the reference data to be compared with the rendered
 // data.
 //
 // jumpThreshold - optional parameter that specifies the threshold to use for detecting
 // discontinuities.  If not specified, defaults to discontinuityThreshold.
 //
-function checkResultFunction(testName, error, referenceFunction, jumpThreshold, errorMetric)
+function checkResultFunction(task, should, testName, error, referenceFunction, jumpThreshold, errorMetric)
 {
     return function(event) {
         var buffer = event.renderedBuffer;
         renderedData = buffer.getChannelData(0);
 
         var threshold;
 
         if (!jumpThreshold) {
             threshold = discontinuityThreshold;
         } else {
             threshold = jumpThreshold;
         }
         
-        compareSignals(testName, error, renderedData, referenceFunction, timeValueInfo, threshold, errorMetric);
-
-        finishJSTest();
+        compareSignals(should, testName, error, renderedData, referenceFunction, timeValueInfo, threshold, errorMetric);
+        task.done();
     }
 }
 
 // Run all the automation tests.
 //
 // numberOfTests - number of tests (time intervals) to run.
 //
 // initialValue - The initial value of the first time interval.
 //
 // setValueFunction - function that sets the specified value at the start of a time interval.
@@ skipping 43 matching lines @@
 // testName - string indicating the test that is being run.
 //
 // maxError - maximum allowed error between the rendered data and the reference data
 //
 // referenceFunction - function that generates the reference data to be compared against the
 // rendered data.
 //
 // jumpThreshold - optional parameter that specifies the threshold to use for detecting
 // discontinuities.  If not specified, defaults to discontinuityThreshold.
 //
-function createAudioGraphAndTest(numberOfTests, initialValue, setValueFunction, automationFunction, testName, maxError, referenceFunction, jumpThreshold, errorMetric)
+function createAudioGraphAndTest(task, should, numberOfTests, initialValue, setValueFunction, automationFunction, testName, maxError, referenceFunction, jumpThreshold, errorMetric)
 {
-    if (window.testRunner) {
-        testRunner.dumpAsText();
-        testRunner.waitUntilDone();
-    }
-
-    window.jsTestIsAsync = true;
-
     // Create offline audio context.
     context = new OfflineAudioContext(2, renderLength(numberOfTests), sampleRate);
     var constantBuffer = createConstantBuffer(context, renderLength(numberOfTests), 1);
 
     // We use an AudioGainNode here simply as a convenient way to test the AudioParam
     // automation, since it's easy to pass a constant value through the node, automate the
     // .gain attribute and observe the resulting values.
 
     gainNode = context.createGain();
 
     var bufferSource = context.createBufferSource();
     bufferSource.buffer = constantBuffer;
     bufferSource.connect(gainNode);
     gainNode.connect(context.destination);
 
     // Set up default values for the parameters that control how the automation test values progress
     // for each time interval.
     startingValueDelta = initialValue / numberOfTests;
     startEndValueChange = startingValueDelta / 2;
     discontinuityThreshold = startEndValueChange / 2;
 
     // Run the automation tests.
     timeValueInfo = doAutomation(numberOfTests,
                                  initialValue,
                                  setValueFunction,
                                  automationFunction);
     bufferSource.start(0);
       
-    context.oncomplete = checkResultFunction(testName,
+    context.oncomplete = checkResultFunction(task, should, testName,
                                              maxError,
                                              referenceFunction,
                                              jumpThreshold,
                                              errorMetric || relativeErrorMetric);
     context.startRendering();
 }