LayoutTests/webaudio/PeriodicWave/ctor-periodicwave.html - WebKit - Git at Google

 <!DOCTYPE html>
 <html>
   <head>
     <title>
       Test Constructor: PeriodicWave
     </title>
     <script src="../../imported/w3c/web-platform-tests/resources/testharness.js"></script>
     <script src="../../resources/testharnessreport.js"></script>
     <script src="../resources/audit-util.js"></script>
     <script src="../resources/audit.js"></script>
     <script src="../resources/audionodeoptions.js"></script>
   </head>
   <body>
     <script id="layout-test-code">
       let context;

       let audit = Audit.createTaskRunner();

       audit.define('initialize', (task, should) => {
         context = initializeContext(should);
         task.done();
       });

       audit.define('invalid constructor', (task, should) => {
         testInvalidConstructor(should, 'PeriodicWave', context);
         task.done();
       });

       audit.define('default constructor', (task, should) => {
         should(() => {
           node = new PeriodicWave(context);
         }, 'node = new PeriodicWave(context)').notThrow();

         task.done();
       });

       audit.define('constructor with options', (task, should) => {
         let node1;
         let options = {real: [1, 1]};
         should(
             () => {
               node1 = new PeriodicWave(context, options);
             },
             'node = new PeriodicWave(context, ' + JSON.stringify(options) + ')')
             .notThrow();
         should(node1 instanceof PeriodicWave, 'node1 instanceof PeriodicWave')
             .beEqualTo(true);

         let node2;
         options = {imag: [1, 1]};
         should(
             () => {
               node2 = new PeriodicWave(context, options);
             },
             'node2 = new PeriodicWave(context, ' + JSON.stringify(options) +
                 ')')
             .notThrow();
         should(node2 instanceof PeriodicWave, 'node2 instanceof PeriodicWave')
             .beEqualTo(true);

         let node3;
         options = {real: [1, 2], imag: [1, 1]};
         should(
             () => {
               node3 = new PeriodicWave(context, options);
             },
             'node3 = new PeriodicWave(context, ' + JSON.stringify(options) +
                 ')')
             .notThrow();
         should(node3 instanceof PeriodicWave, 'node3 instanceof PeriodicWave')
             .beEqualTo(true);

         task.done();
       });

       // The following test that the correct waveforms are produced when various
       // possible PeriodicWave options are used.  These are needed because it's
       // the only way to tell if the various options were correctly applied.

       // TODO(rtoy): These functionality tests should be moved out to a separate
       // file.
       audit.define('1: real periodicwave test', (task, should) => {
         verifyPeriodicWaveOutput(
             should, {real: [0, 2]}, generateReference(Math.cos), 2.7143e-5)
             .then(() => task.done());
       });

       audit.define('2: real periodicwave test', (task, should) => {
         verifyPeriodicWaveOutput(
             should, {real: [0, 2], disableNormalization: false},
             generateReference(Math.cos), 2.7143e-5)
             .then(() => task.done());
       });

       audit.define('3: real periodicwave test', (task, should) => {
         verifyPeriodicWaveOutput(
             should, {real: [0, 2], disableNormalization: true},
             generateReference(x => 2 * Math.cos(x)), 5.4285e-5)
             .then(() => task.done());
       });

       audit.define('1: imag periodicwave test', (task, should) => {
         verifyPeriodicWaveOutput(
             should, {imag: [0, 2]}, generateReference(Math.sin), 2.7262e-5)
             .then(() => task.done());
       });

       audit.define('2: imag periodicwave test', (task, should) => {
         verifyPeriodicWaveOutput(
             should, {imag: [0, 2], disableNormalization: false},
             generateReference(Math.sin), 2.7262e-5)
             .then(() => task.done());
       });

       audit.define('3: imag periodicwave test', (task, should) => {
         verifyPeriodicWaveOutput(
             should, {imag: [0, 2], disableNormalization: true},
             generateReference(x => 2 * Math.sin(x)), 5.4524-5)
             .then(() => task.done());
       });

       audit.define('1: real/imag periodicwave test', (task, should) => {
         verifyPeriodicWaveOutput(
             should, {
               real: [0, 1],
               imag: [0, 1],
             },
             generateReference(x => Math.SQRT1_2 * (Math.sin(x) + Math.cos(x))),
             3.8371e-5)
             .then(() => task.done());
       });

       audit.define('2: real/imag periodicwave test', (task, should) => {
         verifyPeriodicWaveOutput(
             should, {real: [0, 1], imag: [0, 1], disableNormalization: false},
             generateReference(x => Math.SQRT1_2 * (Math.sin(x) + Math.cos(x))),
             2.7225e-5)
             .then(() => task.done());
       });

       audit.define('3: real/imag periodicwave test', (task, should) => {
         verifyPeriodicWaveOutput(
             should, {real: [0, 1], imag: [0, 1], disableNormalization: true},
             generateReference(x => Math.sin(x) + Math.cos(x)), 3.8501e-5)
             .then(() => task.done());
       });

       // Returns a function that generates the expected reference array where
       // the samples are generated by the function |gen|.
       function generateReference(gen) {
         return (length, freq, sampleRate) => {
           let expected = new Float32Array(length);
           let omega = 2 * Math.PI * freq / sampleRate;
           for (let k = 0; k < length; ++k) {
             expected[k] = gen(omega * k);
           }
           return expected;
         };
       }

       // Verify that an oscillator constructed from the given periodic wave
       // produces the expected result.
       function verifyPeriodicWaveOutput(
           should, waveOptions, expectedFunction, threshold) {
         let node;
         // Rather arbitrary sample rate and render length. Length doesn't have
         // to be very long.
         let sampleRate = 48000;
         let renderLength = 0.25;
         let testContext =
             new OfflineAudioContext(1, renderLength * sampleRate, sampleRate);

         let options = {
           periodicWave: new PeriodicWave(testContext, waveOptions)
         };
         node = new OscillatorNode(testContext, options);

         // Create the graph
         node.connect(testContext.destination);
         node.start();

         return testContext.startRendering().then(function(resultBuffer) {
           let actual = resultBuffer.getChannelData(0);
           let expected = expectedFunction(
               actual.length, node.frequency.value, testContext.sampleRate);
           // Actual must match expected to within the (experimentally)
           // determined threshold.
           let message = '';
           if (waveOptions.disableNormalization != undefined)
             message =
                 'disableNormalization: ' + waveOptions.disableNormalization;
           if (waveOptions.real) {
             if (message.length > 0)
               message += ', '
               message += 'real: [' + waveOptions.real + ']';
           }
           if (waveOptions.imag) {
             if (message.length > 0)
               message += ', '
               message += 'imag: [' + waveOptions.imag + ']';
           }
           should(actual, 'Oscillator with periodicWave {' + message + '}')
               .beCloseToArray(expected, {absoluteThreshold: threshold});
         });
       }

       // Verify that the default PeriodicWave produces a sine wave. Use a
       // 2-channel context to verify this.
       function sineWaveTest(should, waveFun, message) {
         // Channel 0 is the output from the PeriodicWave, and channel 1 is the
         // reference oscillator output.
         let context = new OfflineAudioContext(2, 40000, 40000);
         let oscRef =
             new OscillatorNode(context, {type: 'sine', frequency: 440});
         let wave = waveFun(context);
         let oscTest =
             new OscillatorNode(context, {frequency: 440, periodicWave: wave});

         let merger = new ChannelMergerNode(context, {numberOfInputs: 2});

         oscRef.connect(merger, 0, 1);
         oscTest.connect(merger, 0, 0);

         merger.connect(context.destination);

         oscRef.start();
         oscTest.start();

         return context.startRendering().then(output => {
           // The output from the two channels MUST match exactly.
           let actual = output.getChannelData(0);
           let ref = output.getChannelData(1);

           should(actual, message).beEqualToArray(ref);
         });
       }

       audit.define('default wave', (task, should) => {
         // Verify that the default PeriodicWave produces a sine wave.
         sineWaveTest(
             should, (context) => new PeriodicWave(context),
             'new PeriodicWave(context) output')
             .then(() => task.done());
       });

       audit.define('default wave (with dict)', (task, should) => {
         // Verify that the default PeriodicWave produces a sine wave when the
         // PeriodicWaveOptions dictionary is given, but real and imag members
         // are not set.
         sineWaveTest(
             should, (context) => new PeriodicWave(context, {foo: 42}),
             'new PeriodicWave(context, {foo: 42}) output')
             .then(() => task.done());
       });

       audit.run();
     </script>
   </body>
 </html>
	<!DOCTYPE html>
	<html>
	<head>
	<title>
	Test Constructor: PeriodicWave
	</title>
	<script src="../../imported/w3c/web-platform-tests/resources/testharness.js"></script>
	<script src="../../resources/testharnessreport.js"></script>
	<script src="../resources/audit-util.js"></script>
	<script src="../resources/audit.js"></script>
	<script src="../resources/audionodeoptions.js"></script>
	</head>
	<body>
	<script id="layout-test-code">
	let context;

	let audit = Audit.createTaskRunner();

	audit.define('initialize', (task, should) => {
	context = initializeContext(should);
	task.done();
	});

	audit.define('invalid constructor', (task, should) => {
	testInvalidConstructor(should, 'PeriodicWave', context);
	task.done();
	});

	audit.define('default constructor', (task, should) => {
	should(() => {
	node = new PeriodicWave(context);
	}, 'node = new PeriodicWave(context)').notThrow();

	task.done();
	});

	audit.define('constructor with options', (task, should) => {
	let node1;
	let options = {real: [1, 1]};
	should(
	() => {
	node1 = new PeriodicWave(context, options);
	},
	'node = new PeriodicWave(context, ' + JSON.stringify(options) + ')')
	.notThrow();
	should(node1 instanceof PeriodicWave, 'node1 instanceof PeriodicWave')
	.beEqualTo(true);

	let node2;
	options = {imag: [1, 1]};
	should(
	() => {
	node2 = new PeriodicWave(context, options);
	},
	'node2 = new PeriodicWave(context, ' + JSON.stringify(options) +
	')')
	.notThrow();
	should(node2 instanceof PeriodicWave, 'node2 instanceof PeriodicWave')
	.beEqualTo(true);

	let node3;
	options = {real: [1, 2], imag: [1, 1]};
	should(
	() => {
	node3 = new PeriodicWave(context, options);
	},
	'node3 = new PeriodicWave(context, ' + JSON.stringify(options) +
	')')
	.notThrow();
	should(node3 instanceof PeriodicWave, 'node3 instanceof PeriodicWave')
	.beEqualTo(true);

	task.done();
	});

	// The following test that the correct waveforms are produced when various
	// possible PeriodicWave options are used. These are needed because it's
	// the only way to tell if the various options were correctly applied.

	// TODO(rtoy): These functionality tests should be moved out to a separate
	// file.
	audit.define('1: real periodicwave test', (task, should) => {
	verifyPeriodicWaveOutput(
	should, {real: [0, 2]}, generateReference(Math.cos), 2.7143e-5)
	.then(() => task.done());
	});

	audit.define('2: real periodicwave test', (task, should) => {
	verifyPeriodicWaveOutput(
	should, {real: [0, 2], disableNormalization: false},
	generateReference(Math.cos), 2.7143e-5)
	.then(() => task.done());
	});

	audit.define('3: real periodicwave test', (task, should) => {
	verifyPeriodicWaveOutput(
	should, {real: [0, 2], disableNormalization: true},
	generateReference(x => 2 * Math.cos(x)), 5.4285e-5)
	.then(() => task.done());
	});

	audit.define('1: imag periodicwave test', (task, should) => {
	verifyPeriodicWaveOutput(
	should, {imag: [0, 2]}, generateReference(Math.sin), 2.7262e-5)
	.then(() => task.done());
	});

	audit.define('2: imag periodicwave test', (task, should) => {
	verifyPeriodicWaveOutput(
	should, {imag: [0, 2], disableNormalization: false},
	generateReference(Math.sin), 2.7262e-5)
	.then(() => task.done());
	});

	audit.define('3: imag periodicwave test', (task, should) => {
	verifyPeriodicWaveOutput(
	should, {imag: [0, 2], disableNormalization: true},
	generateReference(x => 2 * Math.sin(x)), 5.4524-5)
	.then(() => task.done());
	});

	audit.define('1: real/imag periodicwave test', (task, should) => {
	verifyPeriodicWaveOutput(
	should, {
	real: [0, 1],
	imag: [0, 1],
	},
	generateReference(x => Math.SQRT1_2 * (Math.sin(x) + Math.cos(x))),
	3.8371e-5)
	.then(() => task.done());
	});

	audit.define('2: real/imag periodicwave test', (task, should) => {
	verifyPeriodicWaveOutput(
	should, {real: [0, 1], imag: [0, 1], disableNormalization: false},
	generateReference(x => Math.SQRT1_2 * (Math.sin(x) + Math.cos(x))),
	2.7225e-5)
	.then(() => task.done());
	});

	audit.define('3: real/imag periodicwave test', (task, should) => {
	verifyPeriodicWaveOutput(
	should, {real: [0, 1], imag: [0, 1], disableNormalization: true},
	generateReference(x => Math.sin(x) + Math.cos(x)), 3.8501e-5)
	.then(() => task.done());
	});

	// Returns a function that generates the expected reference array where
	// the samples are generated by the function \|gen\|.
	function generateReference(gen) {
	return (length, freq, sampleRate) => {
	let expected = new Float32Array(length);
	let omega = 2 * Math.PI * freq / sampleRate;
	for (let k = 0; k < length; ++k) {
	expected[k] = gen(omega * k);
	}
	return expected;
	};
	}

	// Verify that an oscillator constructed from the given periodic wave
	// produces the expected result.
	function verifyPeriodicWaveOutput(
	should, waveOptions, expectedFunction, threshold) {
	let node;
	// Rather arbitrary sample rate and render length. Length doesn't have
	// to be very long.
	let sampleRate = 48000;
	let renderLength = 0.25;
	let testContext =
	new OfflineAudioContext(1, renderLength * sampleRate, sampleRate);

	let options = {
	periodicWave: new PeriodicWave(testContext, waveOptions)
	};
	node = new OscillatorNode(testContext, options);

	// Create the graph
	node.connect(testContext.destination);
	node.start();

	return testContext.startRendering().then(function(resultBuffer) {
	let actual = resultBuffer.getChannelData(0);
	let expected = expectedFunction(
	actual.length, node.frequency.value, testContext.sampleRate);
	// Actual must match expected to within the (experimentally)
	// determined threshold.
	let message = '';
	if (waveOptions.disableNormalization != undefined)
	message =
	'disableNormalization: ' + waveOptions.disableNormalization;
	if (waveOptions.real) {
	if (message.length > 0)
	message += ', '
	message += 'real: [' + waveOptions.real + ']';
	}
	if (waveOptions.imag) {
	if (message.length > 0)
	message += ', '
	message += 'imag: [' + waveOptions.imag + ']';
	}
	should(actual, 'Oscillator with periodicWave {' + message + '}')
	.beCloseToArray(expected, {absoluteThreshold: threshold});
	});
	}

	// Verify that the default PeriodicWave produces a sine wave. Use a
	// 2-channel context to verify this.
	function sineWaveTest(should, waveFun, message) {
	// Channel 0 is the output from the PeriodicWave, and channel 1 is the
	// reference oscillator output.
	let context = new OfflineAudioContext(2, 40000, 40000);
	let oscRef =
	new OscillatorNode(context, {type: 'sine', frequency: 440});
	let wave = waveFun(context);
	let oscTest =
	new OscillatorNode(context, {frequency: 440, periodicWave: wave});

	let merger = new ChannelMergerNode(context, {numberOfInputs: 2});

	oscRef.connect(merger, 0, 1);
	oscTest.connect(merger, 0, 0);

	merger.connect(context.destination);

	oscRef.start();
	oscTest.start();

	return context.startRendering().then(output => {
	// The output from the two channels MUST match exactly.
	let actual = output.getChannelData(0);
	let ref = output.getChannelData(1);

	should(actual, message).beEqualToArray(ref);
	});
	}

	audit.define('default wave', (task, should) => {
	// Verify that the default PeriodicWave produces a sine wave.
	sineWaveTest(
	should, (context) => new PeriodicWave(context),
	'new PeriodicWave(context) output')
	.then(() => task.done());
	});

	audit.define('default wave (with dict)', (task, should) => {
	// Verify that the default PeriodicWave produces a sine wave when the
	// PeriodicWaveOptions dictionary is given, but real and imag members
	// are not set.
	sineWaveTest(
	should, (context) => new PeriodicWave(context, {foo: 42}),
	'new PeriodicWave(context, {foo: 42}) output')
	.then(() => task.done());
	});

	audit.run();
	</script>
	</body>
	</html>