LayoutTests/imported/w3c/web-platform-tests/webaudio/the-audio-api/the-audioparam-interface/k-rate-biquad-connection.html - WebKit - Git at Google

 <!doctype html>
 <html>
   <head>
     <title>Test k-rate AudioParam Inputs for BiquadFilterNode</title>
     <script src="/resources/testharness.js"></script>
     <script src="/resources/testharnessreport.js"></script>
     <script src="/webaudio/resources/audit-util.js"></script>
     <script src="/webaudio/resources/audit.js"></script>
   </head>

   <body>
     <script>
       // sampleRate and duration are fairly arbitrary.  We use low values to
       // limit the complexity of the test.
       let sampleRate = 8192;
       let testDuration = 0.5;

       let audit = Audit.createTaskRunner();

       audit.define(
           {label: 'Frequency AudioParam', description: 'k-rate input works'},
           async (task, should) => {
             // Test frequency AudioParam using a lowpass filter whose bandwidth
             // is initially larger than the oscillator frequency.  Then automate
             // the frequency to 0 so that the output of the filter is 0 (because
             // the cutoff is 0).
             let oscFrequency = 440;

             let options = {
               sampleRate: sampleRate,
               paramName: 'frequency',
               oscFrequency: oscFrequency,
               testDuration: testDuration,
               filterOptions: {type: 'lowpass', frequency: 0},
               autoStart:
                   {method: 'setValueAtTime', args: [2 * oscFrequency, 0]},
               autoEnd: {
                 method: 'linearRampToValueAtTime',
                 args: [0, testDuration / 4]
               }
             };

             let buffer = await doTest(should, options);
             let expected = buffer.getChannelData(0);
             let actual = buffer.getChannelData(1);
             let halfLength = expected.length / 2;

             // Sanity check.  The expected output should not be zero for
             // the first half, but should be zero for the second half
             // (because the filter bandwidth is exactly 0).
             const prefix = 'Expected k-rate frequency with automation';

             should(
                 expected.slice(0, halfLength),
                 `${prefix} output[0:${halfLength - 1}]`)
                 .notBeConstantValueOf(0);
             should(
                 expected.slice(expected.length),
                 `${prefix} output[${halfLength}:]`)
                 .beConstantValueOf(0);

             // Outputs should be the same.  Break the message into two
             // parts so we can see the expected outputs.
             checkForSameOutput(should, options.paramName, actual, expected);

             task.done();
           });

       audit.define(
           {label: 'Q AudioParam', description: 'k-rate input works'},
           async (task, should) => {
             // Test Q AudioParam.  Use a bandpass filter whose center frequency
             // is fairly far from the oscillator frequency.  Then start with a Q
             // value of 0 (so everything goes through) and then increase Q to
             // some large value such that the out-of-band signals are basically
             // cutoff.
             let frequency = 440;
             let oscFrequency = 4 * frequency;

             let options = {
               sampleRate: sampleRate,
               oscFrequency: oscFrequency,
               testDuration: testDuration,
               paramName: 'Q',
               filterOptions: {type: 'bandpass', frequency: frequency, Q: 0},
               autoStart: {method: 'setValueAtTime', args: [0, 0]},
               autoEnd: {
                 method: 'linearRampToValueAtTime',
                 args: [100, testDuration / 4]
               }
             };

             const buffer = await doTest(should, options);
             let expected = buffer.getChannelData(0);
             let actual = buffer.getChannelData(1);

             // Outputs should be the same
             checkForSameOutput(should, options.paramName, actual, expected);

             task.done();
           });

       audit.define(
           {label: 'Gain AudioParam', description: 'k-rate input works'},
           async (task, should) => {
             // Test gain AudioParam.  Use a peaking filter with a large Q so the
             // peak is narrow with a center frequency the same as the oscillator
             // frequency.  Start with a gain of 0 so everything goes through and
             // then ramp the gain down to -100 so that the oscillator is
             // filtered out.
             let oscFrequency = 4 * 440;

             let options = {
               sampleRate: sampleRate,
               oscFrequency: oscFrequency,
               testDuration: testDuration,
               paramName: 'gain',
               filterOptions:
                   {type: 'peaking', frequency: oscFrequency, Q: 100, gain: 0},
               autoStart: {method: 'setValueAtTime', args: [0, 0]},
               autoEnd: {
                 method: 'linearRampToValueAtTime',
                 args: [-100, testDuration / 4]
               }
             };

             const buffer = await doTest(should, options);
             let expected = buffer.getChannelData(0);
             let actual = buffer.getChannelData(1);

             // Outputs should be the same
             checkForSameOutput(should, options.paramName, actual, expected);

             task.done();
           });

       audit.define(
           {label: 'Detune AudioParam', description: 'k-rate input works'},
           async (task, should) => {
             // Test detune AudioParam.  The basic idea is the same as the
             // frequency test above, but insteda of automating the frequency, we
             // automate the detune value so that initially the filter cutuff is
             // unchanged and then changing the detune until the cutoff goes to 1
             // Hz, which would cause the oscillator to be filtered out.
             let oscFrequency = 440;
             let filterFrequency = 5 * oscFrequency;

             // For a detune value d, the computed frequency, fc, of the filter
             // is fc = f*2^(d/1200), where f is the frequency of the filter.  Or
             // d = 1200*log2(fc/f).  Compute the detune value to produce a final
             // cutoff frequency of 1 Hz.
             let detuneEnd = 1200 * Math.log2(1 / filterFrequency);

             let options = {
               sampleRate: sampleRate,
               oscFrequency: oscFrequency,
               testDuration: testDuration,
               paramName: 'detune',
               filterOptions: {
                 type: 'lowpass',
                 frequency: filterFrequency,
                 detune: 0,
                 gain: 0
               },
               autoStart: {method: 'setValueAtTime', args: [0, 0]},
               autoEnd: {
                 method: 'linearRampToValueAtTime',
                 args: [detuneEnd, testDuration / 4]
               }
             };

             const buffer = await doTest(should, options);
             let expected = buffer.getChannelData(0);
             let actual = buffer.getChannelData(1);

             // Outputs should be the same
             checkForSameOutput(should, options.paramName, actual, expected);

             task.done();
           });

       audit.define('All k-rate inputs', async (task, should) => {
         // Test the case where all AudioParams are set to k-rate with an input
         // to each AudioParam.  Similar to the above tests except all the params
         // are k-rate.
         let testFrames = testDuration * sampleRate;
         let context = new OfflineAudioContext(
             {numberOfChannels: 2, sampleRate: sampleRate, length: testFrames});

         let merger = new ChannelMergerNode(
             context, {numberOfInputs: context.destination.channelCount});
         merger.connect(context.destination);

         let src = new OscillatorNode(context);

         // The peaking filter uses all four AudioParams, so this is the node to
         // test.
         let filterOptions =
             {type: 'peaking', frequency: 0, detune: 0, gain: 0, Q: 0};
         let refNode;
         should(
             () => refNode = new BiquadFilterNode(context, filterOptions),
             `Create: refNode = new BiquadFilterNode(context, ${
                 JSON.stringify(filterOptions)})`)
             .notThrow();

         let tstNode;
         should(
             () => tstNode = new BiquadFilterNode(context, filterOptions),
             `Create: tstNode = new BiquadFilterNode(context, ${
                 JSON.stringify(filterOptions)})`)
             .notThrow();
         ;

         // Make all the AudioParams k-rate.
         ['frequency', 'Q', 'gain', 'detune'].forEach(param => {
           should(
               () => refNode[param].automationRate = 'k-rate',
               `Set rate: refNode[${param}].automationRate = 'k-rate'`)
               .notThrow();
           should(
               () => tstNode[param].automationRate = 'k-rate',
               `Set rate: tstNode[${param}].automationRate = 'k-rate'`)
               .notThrow();
         });

         // One input for each AudioParam.
         let mod = {};
         ['frequency', 'Q', 'gain', 'detune'].forEach(param => {
           should(
               () => mod[param] = new ConstantSourceNode(context, {offset: 0}),
               `Create: mod[${
                   param}] = new ConstantSourceNode(context, {offset: 0})`)
               .notThrow();
           ;
           should(
               () => mod[param].offset.automationRate = 'a-rate',
               `Set rate: mod[${param}].offset.automationRate = 'a-rate'`)
               .notThrow();
         });

         // Set up automations for refNode.  We want to start the filter with
         // parameters that let the oscillator signal through more or less
         // untouched.  Then change the filter parameters to filter out the
         // oscillator.  What happens in between doesn't reall matter for this
         // test.  Hence, set the initial parameters with a center frequency well
         // above the oscillator and a Q and gain of 0 to pass everthing.
         [['frequency', [4 * src.frequency.value, 0]], ['Q', [0, 0]],
          ['gain', [0, 0]], ['detune', [4 * 1200, 0]]]
             .forEach(param => {
               should(
                   () => refNode[param[0]].setValueAtTime(...param[1]),
                   `Automate 0: refNode.${param[0]}.setValueAtTime(${
                       param[1][0]}, ${param[1][1]})`)
                   .notThrow();
               should(
                   () => mod[param[0]].offset.setValueAtTime(...param[1]),
                   `Automate 0: mod[${param[0]}].offset.setValueAtTime(${
                       param[1][0]}, ${param[1][1]})`)
                   .notThrow();
             });

         // Now move the filter frequency to the oscillator frequency with a high
         // Q and very low gain to remove the oscillator signal.
         [['frequency', [src.frequency.value, testDuration / 4]],
          ['Q', [40, testDuration / 4]], ['gain', [-100, testDuration / 4]], [
            'detune', [0, testDuration / 4]
          ]].forEach(param => {
           should(
               () => refNode[param[0]].linearRampToValueAtTime(...param[1]),
               `Automate 1: refNode[${param[0]}].linearRampToValueAtTime(${
                   param[1][0]}, ${param[1][1]})`)
               .notThrow();
           should(
               () => mod[param[0]].offset.linearRampToValueAtTime(...param[1]),
               `Automate 1: mod[${param[0]}].offset.linearRampToValueAtTime(${
                   param[1][0]}, ${param[1][1]})`)
               .notThrow();
         });

         // Connect everything
         src.connect(refNode).connect(merger, 0, 0);
         src.connect(tstNode).connect(merger, 0, 1);

         src.start();
         for (let param in mod) {
           should(
               () => mod[param].connect(tstNode[param]),
               `Connect: mod[${param}].connect(tstNode.${param})`)
               .notThrow();
         }

         for (let param in mod) {
           should(() => mod[param].start(), `Start: mod[${param}].start()`)
               .notThrow();
         }

         const buffer = await context.startRendering();
         let expected = buffer.getChannelData(0);
         let actual = buffer.getChannelData(1);

         // Sanity check that the output isn't all zeroes.
         should(actual, 'All k-rate AudioParams').notBeConstantValueOf(0);
         should(actual, 'All k-rate AudioParams').beCloseToArray(expected, {
           absoluteThreshold: 0
         });

         task.done();
       });

       audit.run();

       async function doTest(should, options) {
         // Test that a k-rate AudioParam with an input reads the input value and
         // is actually k-rate.
         //
         // A refNode is created with an automation timeline.  This is the
         // expected output.
         //
         // The testNode is the same, but it has a node connected to the k-rate
         // AudioParam.  The input to the node is an a-rate ConstantSourceNode
         // whose output is automated in exactly the same was as the refNode.  If
         // the test passes, the outputs of the two nodes MUST match exactly.

         // The options argument MUST contain the following members:
         //   sampleRate - the sample rate for the offline context
         //   testDuration - duration of the offline context, in sec.
         //   paramName  - the name of the AudioParam to be tested
         //   oscFrequency - frequency of oscillator source
         //   filterOptions - options used to construct the BiquadFilterNode
         //   autoStart     - information about how to start the automation
         //   autoEnd       - information about how to end the automation
         //
         //   The autoStart and autoEnd options are themselves dictionaries with
         //   the following required members:
         //     method - name of the automation method to be applied
         //     args   - array of arguments to be supplied to the method.
         let {
           sampleRate,
           paramName,
           oscFrequency,
           autoStart,
           autoEnd,
           testDuration,
           filterOptions
         } = options;

         let testFrames = testDuration * sampleRate;
         let context = new OfflineAudioContext(
             {numberOfChannels: 2, sampleRate: sampleRate, length: testFrames});

         let merger = new ChannelMergerNode(
             context, {numberOfInputs: context.destination.channelCount});
         merger.connect(context.destination);

         // Any calls to |should| are meant to be informational so we can see
         // what nodes are created and the automations used.
         let src;

         // Create the source.
         should(
             () => {
               src = new OscillatorNode(context, {frequency: oscFrequency});
             },
             `${paramName}: new OscillatorNode(context, {frequency: ${
                 oscFrequency}})`)
             .notThrow();

         // The refNode automates the AudioParam with k-rate automations, no
         // inputs.
         let refNode;
         should(
             () => {
               refNode = new BiquadFilterNode(context, filterOptions);
             },
             `Reference BiquadFilterNode(c, ${JSON.stringify(filterOptions)})`)
             .notThrow();

         refNode[paramName].automationRate = 'k-rate';

         // Set up automations for the reference node.
         should(
             () => {
               refNode[paramName][autoStart.method](...autoStart.args);
             },
             `refNode.${paramName}.${autoStart.method}(${autoStart.args})`)
             .notThrow();
         should(
             () => {
               refNode[paramName][autoEnd.method](...autoEnd.args);
             },
             `refNode.${paramName}.${autoEnd.method}.(${autoEnd.args})`)
             .notThrow();

         // The tstNode does the same automation, but it comes from the input
         // connected to the AudioParam.
         let tstNode;
         should(
             () => {
               tstNode = new BiquadFilterNode(context, filterOptions);
             },
             `Test BiquadFilterNode(context, ${JSON.stringify(filterOptions)})`)
             .notThrow();
         tstNode[paramName].automationRate = 'k-rate';

         // Create the input to the AudioParam of the test node.  The output of
         // this node MUST have the same set of automations as the reference
         // node, and MUST be a-rate to make sure we're handling k-rate inputs
         // correctly.
         let mod = new ConstantSourceNode(context);
         mod.offset.automationRate = 'a-rate';
         should(
             () => {
               mod.offset[autoStart.method](...autoStart.args);
             },
             `${paramName}: mod.offset.${autoStart.method}(${autoStart.args})`)
             .notThrow();
         should(
             () => {
               mod.offset[autoEnd.method](...autoEnd.args);
             },
             `${paramName}: mod.offset.${autoEnd.method}(${autoEnd.args})`)
             .notThrow();

         // Create graph
         mod.connect(tstNode[paramName]);
         src.connect(refNode).connect(merger, 0, 0);
         src.connect(tstNode).connect(merger, 0, 1);

         // Run!
         src.start();
         mod.start();
         return context.startRendering();
       }

       function checkForSameOutput(should, paramName, actual, expected) {
         let halfLength = expected.length / 2;

         // Outputs should be the same.  We break the check into halves so we can
         // see the expected outputs.  Mostly for a simple visual check that the
         // output from the second half is small because the tests generally try
         // to filter out the signal so that the last half of the output is
         // small.
         should(
             actual.slice(0, halfLength),
             `k-rate ${paramName} with input: output[0,${halfLength}]`)
             .beCloseToArray(
                 expected.slice(0, halfLength), {absoluteThreshold: 0});
         should(
             actual.slice(halfLength),
             `k-rate ${paramName} with input: output[${halfLength}:]`)
             .beCloseToArray(expected.slice(halfLength), {absoluteThreshold: 0});
       }
     </script>
   </body>
 </html>
	<!doctype html>
	<html>
	<head>
	<title>Test k-rate AudioParam Inputs for BiquadFilterNode</title>
	<script src="/resources/testharness.js"></script>
	<script src="/resources/testharnessreport.js"></script>
	<script src="/webaudio/resources/audit-util.js"></script>
	<script src="/webaudio/resources/audit.js"></script>
	</head>

	<body>
	<script>
	// sampleRate and duration are fairly arbitrary. We use low values to
	// limit the complexity of the test.
	let sampleRate = 8192;
	let testDuration = 0.5;

	let audit = Audit.createTaskRunner();

	audit.define(
	{label: 'Frequency AudioParam', description: 'k-rate input works'},
	async (task, should) => {
	// Test frequency AudioParam using a lowpass filter whose bandwidth
	// is initially larger than the oscillator frequency. Then automate
	// the frequency to 0 so that the output of the filter is 0 (because
	// the cutoff is 0).
	let oscFrequency = 440;

	let options = {
	sampleRate: sampleRate,
	paramName: 'frequency',
	oscFrequency: oscFrequency,
	testDuration: testDuration,
	filterOptions: {type: 'lowpass', frequency: 0},
	autoStart:
	{method: 'setValueAtTime', args: [2 * oscFrequency, 0]},
	autoEnd: {
	method: 'linearRampToValueAtTime',
	args: [0, testDuration / 4]
	}
	};

	let buffer = await doTest(should, options);
	let expected = buffer.getChannelData(0);
	let actual = buffer.getChannelData(1);
	let halfLength = expected.length / 2;

	// Sanity check. The expected output should not be zero for
	// the first half, but should be zero for the second half
	// (because the filter bandwidth is exactly 0).
	const prefix = 'Expected k-rate frequency with automation';

	should(
	expected.slice(0, halfLength),
	`${prefix} output[0:${halfLength - 1}]`)
	.notBeConstantValueOf(0);
	should(
	expected.slice(expected.length),
	`${prefix} output[${halfLength}:]`)
	.beConstantValueOf(0);

	// Outputs should be the same. Break the message into two
	// parts so we can see the expected outputs.
	checkForSameOutput(should, options.paramName, actual, expected);

	task.done();
	});

	audit.define(
	{label: 'Q AudioParam', description: 'k-rate input works'},
	async (task, should) => {
	// Test Q AudioParam. Use a bandpass filter whose center frequency
	// is fairly far from the oscillator frequency. Then start with a Q
	// value of 0 (so everything goes through) and then increase Q to
	// some large value such that the out-of-band signals are basically
	// cutoff.
	let frequency = 440;
	let oscFrequency = 4 * frequency;

	let options = {
	sampleRate: sampleRate,
	oscFrequency: oscFrequency,
	testDuration: testDuration,
	paramName: 'Q',
	filterOptions: {type: 'bandpass', frequency: frequency, Q: 0},
	autoStart: {method: 'setValueAtTime', args: [0, 0]},
	autoEnd: {
	method: 'linearRampToValueAtTime',
	args: [100, testDuration / 4]
	}
	};

	const buffer = await doTest(should, options);
	let expected = buffer.getChannelData(0);
	let actual = buffer.getChannelData(1);

	// Outputs should be the same
	checkForSameOutput(should, options.paramName, actual, expected);

	task.done();
	});

	audit.define(
	{label: 'Gain AudioParam', description: 'k-rate input works'},
	async (task, should) => {
	// Test gain AudioParam. Use a peaking filter with a large Q so the
	// peak is narrow with a center frequency the same as the oscillator
	// frequency. Start with a gain of 0 so everything goes through and
	// then ramp the gain down to -100 so that the oscillator is
	// filtered out.
	let oscFrequency = 4 * 440;

	let options = {
	sampleRate: sampleRate,
	oscFrequency: oscFrequency,
	testDuration: testDuration,
	paramName: 'gain',
	filterOptions:
	{type: 'peaking', frequency: oscFrequency, Q: 100, gain: 0},
	autoStart: {method: 'setValueAtTime', args: [0, 0]},
	autoEnd: {
	method: 'linearRampToValueAtTime',
	args: [-100, testDuration / 4]
	}
	};

	const buffer = await doTest(should, options);
	let expected = buffer.getChannelData(0);
	let actual = buffer.getChannelData(1);

	// Outputs should be the same
	checkForSameOutput(should, options.paramName, actual, expected);

	task.done();
	});

	audit.define(
	{label: 'Detune AudioParam', description: 'k-rate input works'},
	async (task, should) => {
	// Test detune AudioParam. The basic idea is the same as the
	// frequency test above, but insteda of automating the frequency, we
	// automate the detune value so that initially the filter cutuff is
	// unchanged and then changing the detune until the cutoff goes to 1
	// Hz, which would cause the oscillator to be filtered out.
	let oscFrequency = 440;
	let filterFrequency = 5 * oscFrequency;

	// For a detune value d, the computed frequency, fc, of the filter
	// is fc = f*2^(d/1200), where f is the frequency of the filter. Or
	// d = 1200*log2(fc/f). Compute the detune value to produce a final
	// cutoff frequency of 1 Hz.
	let detuneEnd = 1200 * Math.log2(1 / filterFrequency);

	let options = {
	sampleRate: sampleRate,
	oscFrequency: oscFrequency,
	testDuration: testDuration,
	paramName: 'detune',
	filterOptions: {
	type: 'lowpass',
	frequency: filterFrequency,
	detune: 0,
	gain: 0
	},
	autoStart: {method: 'setValueAtTime', args: [0, 0]},
	autoEnd: {
	method: 'linearRampToValueAtTime',
	args: [detuneEnd, testDuration / 4]
	}
	};

	const buffer = await doTest(should, options);
	let expected = buffer.getChannelData(0);
	let actual = buffer.getChannelData(1);

	// Outputs should be the same
	checkForSameOutput(should, options.paramName, actual, expected);

	task.done();
	});

	audit.define('All k-rate inputs', async (task, should) => {
	// Test the case where all AudioParams are set to k-rate with an input
	// to each AudioParam. Similar to the above tests except all the params
	// are k-rate.
	let testFrames = testDuration * sampleRate;
	let context = new OfflineAudioContext(
	{numberOfChannels: 2, sampleRate: sampleRate, length: testFrames});

	let merger = new ChannelMergerNode(
	context, {numberOfInputs: context.destination.channelCount});
	merger.connect(context.destination);

	let src = new OscillatorNode(context);

	// The peaking filter uses all four AudioParams, so this is the node to
	// test.
	let filterOptions =
	{type: 'peaking', frequency: 0, detune: 0, gain: 0, Q: 0};
	let refNode;
	should(
	() => refNode = new BiquadFilterNode(context, filterOptions),
	`Create: refNode = new BiquadFilterNode(context, ${
	JSON.stringify(filterOptions)})`)
	.notThrow();

	let tstNode;
	should(
	() => tstNode = new BiquadFilterNode(context, filterOptions),
	`Create: tstNode = new BiquadFilterNode(context, ${
	JSON.stringify(filterOptions)})`)
	.notThrow();
	;

	// Make all the AudioParams k-rate.
	['frequency', 'Q', 'gain', 'detune'].forEach(param => {
	should(
	() => refNode[param].automationRate = 'k-rate',
	`Set rate: refNode[${param}].automationRate = 'k-rate'`)
	.notThrow();
	should(
	() => tstNode[param].automationRate = 'k-rate',
	`Set rate: tstNode[${param}].automationRate = 'k-rate'`)
	.notThrow();
	});

	// One input for each AudioParam.
	let mod = {};
	['frequency', 'Q', 'gain', 'detune'].forEach(param => {
	should(
	() => mod[param] = new ConstantSourceNode(context, {offset: 0}),
	`Create: mod[${
	param}] = new ConstantSourceNode(context, {offset: 0})`)
	.notThrow();
	;
	should(
	() => mod[param].offset.automationRate = 'a-rate',
	`Set rate: mod[${param}].offset.automationRate = 'a-rate'`)
	.notThrow();
	});

	// Set up automations for refNode. We want to start the filter with
	// parameters that let the oscillator signal through more or less
	// untouched. Then change the filter parameters to filter out the
	// oscillator. What happens in between doesn't reall matter for this
	// test. Hence, set the initial parameters with a center frequency well
	// above the oscillator and a Q and gain of 0 to pass everthing.
	[['frequency', [4 * src.frequency.value, 0]], ['Q', [0, 0]],
	['gain', [0, 0]], ['detune', [4 * 1200, 0]]]
	.forEach(param => {
	should(
	() => refNode[param[0]].setValueAtTime(...param[1]),
	`Automate 0: refNode.${param[0]}.setValueAtTime(${
	param[1][0]}, ${param[1][1]})`)
	.notThrow();
	should(
	() => mod[param[0]].offset.setValueAtTime(...param[1]),
	`Automate 0: mod[${param[0]}].offset.setValueAtTime(${
	param[1][0]}, ${param[1][1]})`)
	.notThrow();
	});

	// Now move the filter frequency to the oscillator frequency with a high
	// Q and very low gain to remove the oscillator signal.
	[['frequency', [src.frequency.value, testDuration / 4]],
	['Q', [40, testDuration / 4]], ['gain', [-100, testDuration / 4]], [
	'detune', [0, testDuration / 4]
	]].forEach(param => {
	should(
	() => refNode[param[0]].linearRampToValueAtTime(...param[1]),
	`Automate 1: refNode[${param[0]}].linearRampToValueAtTime(${
	param[1][0]}, ${param[1][1]})`)
	.notThrow();
	should(
	() => mod[param[0]].offset.linearRampToValueAtTime(...param[1]),
	`Automate 1: mod[${param[0]}].offset.linearRampToValueAtTime(${
	param[1][0]}, ${param[1][1]})`)
	.notThrow();
	});

	// Connect everything
	src.connect(refNode).connect(merger, 0, 0);
	src.connect(tstNode).connect(merger, 0, 1);

	src.start();
	for (let param in mod) {
	should(
	() => mod[param].connect(tstNode[param]),
	`Connect: mod[${param}].connect(tstNode.${param})`)
	.notThrow();
	}

	for (let param in mod) {
	should(() => mod[param].start(), `Start: mod[${param}].start()`)
	.notThrow();
	}

	const buffer = await context.startRendering();
	let expected = buffer.getChannelData(0);
	let actual = buffer.getChannelData(1);

	// Sanity check that the output isn't all zeroes.
	should(actual, 'All k-rate AudioParams').notBeConstantValueOf(0);
	should(actual, 'All k-rate AudioParams').beCloseToArray(expected, {
	absoluteThreshold: 0
	});

	task.done();
	});

	audit.run();

	async function doTest(should, options) {
	// Test that a k-rate AudioParam with an input reads the input value and
	// is actually k-rate.
	//
	// A refNode is created with an automation timeline. This is the
	// expected output.
	//
	// The testNode is the same, but it has a node connected to the k-rate
	// AudioParam. The input to the node is an a-rate ConstantSourceNode
	// whose output is automated in exactly the same was as the refNode. If
	// the test passes, the outputs of the two nodes MUST match exactly.

	// The options argument MUST contain the following members:
	// sampleRate - the sample rate for the offline context
	// testDuration - duration of the offline context, in sec.
	// paramName - the name of the AudioParam to be tested
	// oscFrequency - frequency of oscillator source
	// filterOptions - options used to construct the BiquadFilterNode
	// autoStart - information about how to start the automation
	// autoEnd - information about how to end the automation
	//
	// The autoStart and autoEnd options are themselves dictionaries with
	// the following required members:
	// method - name of the automation method to be applied
	// args - array of arguments to be supplied to the method.
	let {
	sampleRate,
	paramName,
	oscFrequency,
	autoStart,
	autoEnd,
	testDuration,
	filterOptions
	} = options;

	let testFrames = testDuration * sampleRate;
	let context = new OfflineAudioContext(
	{numberOfChannels: 2, sampleRate: sampleRate, length: testFrames});

	let merger = new ChannelMergerNode(
	context, {numberOfInputs: context.destination.channelCount});
	merger.connect(context.destination);

	// Any calls to \|should\| are meant to be informational so we can see
	// what nodes are created and the automations used.
	let src;

	// Create the source.
	should(
	() => {
	src = new OscillatorNode(context, {frequency: oscFrequency});
	},
	`${paramName}: new OscillatorNode(context, {frequency: ${
	oscFrequency}})`)
	.notThrow();

	// The refNode automates the AudioParam with k-rate automations, no
	// inputs.
	let refNode;
	should(
	() => {
	refNode = new BiquadFilterNode(context, filterOptions);
	},
	`Reference BiquadFilterNode(c, ${JSON.stringify(filterOptions)})`)
	.notThrow();

	refNode[paramName].automationRate = 'k-rate';

	// Set up automations for the reference node.
	should(
	() => {
	refNode[paramName][autoStart.method](...autoStart.args);
	},
	`refNode.${paramName}.${autoStart.method}(${autoStart.args})`)
	.notThrow();
	should(
	() => {
	refNode[paramName][autoEnd.method](...autoEnd.args);
	},
	`refNode.${paramName}.${autoEnd.method}.(${autoEnd.args})`)
	.notThrow();

	// The tstNode does the same automation, but it comes from the input
	// connected to the AudioParam.
	let tstNode;
	should(
	() => {
	tstNode = new BiquadFilterNode(context, filterOptions);
	},
	`Test BiquadFilterNode(context, ${JSON.stringify(filterOptions)})`)
	.notThrow();
	tstNode[paramName].automationRate = 'k-rate';

	// Create the input to the AudioParam of the test node. The output of
	// this node MUST have the same set of automations as the reference
	// node, and MUST be a-rate to make sure we're handling k-rate inputs
	// correctly.
	let mod = new ConstantSourceNode(context);
	mod.offset.automationRate = 'a-rate';
	should(
	() => {
	mod.offset[autoStart.method](...autoStart.args);
	},
	`${paramName}: mod.offset.${autoStart.method}(${autoStart.args})`)
	.notThrow();
	should(
	() => {
	mod.offset[autoEnd.method](...autoEnd.args);
	},
	`${paramName}: mod.offset.${autoEnd.method}(${autoEnd.args})`)
	.notThrow();

	// Create graph
	mod.connect(tstNode[paramName]);
	src.connect(refNode).connect(merger, 0, 0);
	src.connect(tstNode).connect(merger, 0, 1);

	// Run!
	src.start();
	mod.start();
	return context.startRendering();
	}

	function checkForSameOutput(should, paramName, actual, expected) {
	let halfLength = expected.length / 2;

	// Outputs should be the same. We break the check into halves so we can
	// see the expected outputs. Mostly for a simple visual check that the
	// output from the second half is small because the tests generally try
	// to filter out the signal so that the last half of the output is
	// small.
	should(
	actual.slice(0, halfLength),
	`k-rate ${paramName} with input: output[0,${halfLength}]`)
	.beCloseToArray(
	expected.slice(0, halfLength), {absoluteThreshold: 0});
	should(
	actual.slice(halfLength),
	`k-rate ${paramName} with input: output[${halfLength}:]`)
	.beCloseToArray(expected.slice(halfLength), {absoluteThreshold: 0});
	}
	</script>
	</body>
	</html>