Convert Oscillator sweep tests to testharness

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

 // Notes about generated waveforms:
 //
 // QUESTION: Why does the wave shape not look like the exact shape (sharp edges)?
 // ANSWER: Because a shape with sharp edges has infinitely high frequency content.
 // Since a digital audio signal must be band-limited based on the nyquist frequency (half the sample-rate)
 // in order to avoid aliasing, this creates more rounded edges and "ringing" in the
 // appearance of the waveform.  See Nyquist-Shannon sampling theorem:
 // http://en.wikipedia.org/wiki/Nyquist%E2%80%93Shannon_sampling_theorem
 //
 // QUESTION: Why does the very end of the generated signal appear to get slightly weaker?
@@ skipping 49 matching lines @@
 
 // Count the number of differences between the expected and actual result. The tests passes
 // if the count is less than this threshold.
 var thresholdDiffCount = 0;
 
 // Mostly for debugging
 
 // An AudioBuffer for the reference (expected) result.
 var reference = 0;
 
-// The actual rendered data produced by the test.
-var renderedData = 0;
-
 // Signal power of the reference
 var signalPower = 0;
 
 // Noise power of the difference between the reference and actual result.
 var noisePower = 0;
 
 function generateExponentialOscillatorSweep(context, oscillatorType) {
     var osc = context.createOscillator();
     if (oscillatorType == "custom") {
         // Create a simple waveform with three Fourier coefficients.
@@ skipping 19 matching lines @@
 }
 
 function calculateSNR(sPower, nPower)
 {
     if (nPower == 0 && sPower > 0) {
         return 1000;
     }
     return 10 * Math.log10(sPower / nPower);
 }
 
-function loadReferenceAndRunTest(oscType) {
-    var bufferLoader = new BufferLoader(
+function loadReferenceAndRunTest(context, oscType, task, should) {
+     var bufferLoader = new BufferLoader(
         context,
         [ "../Oscillator/oscillator-" + oscType + "-expected.wav" ],
         function (bufferList) {
             reference = bufferList[0].getChannelData(0);
             generateExponentialOscillatorSweep(context, oscType);
-            context.oncomplete = checkResult;
+            context.oncomplete = () => {
+              checkResult(event, should);
+              task.done();
+            };
             context.startRendering();
         });
 
     bufferLoader.load();
 }
 
-function checkResult (event) {
-    renderedData = event.renderedBuffer.getChannelData(0);
+function checkResult (event, should) {
+    let renderedData = event.renderedBuffer.getChannelData(0);
     // Compute signal to noise ratio between the result and the reference. Also keep track
     // of the max difference (and position).
 
     var maxError = -1;
     var errorPosition = -1;
     var diffCount = 0;
 
     for (var k = 0; k < renderedData.length; ++k) {
         var diff = renderedData[k] - reference[k];
         noisePower += diff * diff;
         signalPower += reference[k] * reference[k];
         if (Math.abs(diff) > maxError) {
             maxError = Math.abs(diff);
             errorPosition = k;
         }
         // The reference file is a 16-bit WAV file, so we will almost never get an exact match
         // between it and the actual floating-point result.
         if (diff > 1/waveScaleFactor) {
             diffCount++;
         }
     }
 
     var snr = calculateSNR(signalPower, noisePower);
-    if (snr >= thresholdSNR) {
-        testPassed("Exceeded SNR threshold of " + thresholdSNR + " dB");
-    } else {
-        testFailed("Expected SNR of " + thresholdSNR + " dB, but actual SNR is " + snr + " dB");
-    }
+    should(snr, "SNR")
+        .beGreaterThanOrEqualTo(thresholdSNR);
+    should(maxError * waveScaleFactor, "Maximum difference in ulp (16-bits)")
+        .beLessThanOrEqualTo(thresholdDiff * waveScaleFactor);
 
-    if (maxError <= thresholdDiff) {
-        testPassed("Maximum difference below threshold of "
-                   + (thresholdDiff * waveScaleFactor) + " ulp (16-bits)");
-    } else {
-        testFailed("Maximum difference of " + (maxError * waveScaleFactor) + " at "
-                   + errorPosition + " exceeded threshold of " + (thresholdDiff * waveScaleFactor)
-                   + " ulp (16-bits)");
-    }
-
-    if (diffCount <= thresholdDiffCount) {
-        testPassed("Number of differences between actual and expected result is less than " + thresholdDiffCount
-                   + " out of " + renderedData.length);
-    } else {
-        testFailed(diffCount + " differences found but expected no more than " + thresholdDiffCount
-                   + " out of " + renderedData.length);
-    }
-
-    finishJSTest();
+    should(diffCount,
+           "Number of differences between actual and expected result out of "
+           + renderedData.length + " frames")
+        .beLessThanOrEqualTo(thresholdDiffCount);
 }
 
 function setThresholds(thresholds) {
     thresholdSNR = thresholds.snr;
     thresholdDiff = thresholds.maxDiff / waveScaleFactor;
     thresholdDiffCount = thresholds.diffCount;
 }
 
-function runTest(oscType) {
-    window.jsTestIsAsync = true;
-    context = new OfflineAudioContext(1, sampleRate * lengthInSeconds, sampleRate);
-    loadReferenceAndRunTest(oscType);
+function runTest(context, oscType, description, task, should) {
+  loadReferenceAndRunTest(context, oscType, task, should);
 }
 
 function createNewReference(oscType) {
      if (!window.testRunner)
          return;
 
      context = new OfflineAudioContext(1, sampleRate * lengthInSeconds, sampleRate);
      generateExponentialOscillatorSweep(context, oscType);
 
      context.oncomplete = finishAudioTest;
      context.startRendering();
 
      testRunner.waitUntilDone();
 }
 
 return {
     sampleRate: sampleRate,
     lengthInSeconds: lengthInSeconds,
     thresholdSNR: thresholdSNR,
     thresholdDiff: thresholdDiff,
     thresholdDiffCount: thresholdDiffCount,
     waveScaleFactor: waveScaleFactor,
     setThresholds: setThresholds,
-    loadReferenceAndRunTest: loadReferenceAndRunTest,
     runTest: runTest,
     createNewReference: createNewReference,
 };
 
 }());