chromium/src/third_party/blink/web_tests/webaudio/decodeAudioData/decode-audio-data-basic.html - manifest_repos/chromium_src - Git at Google

 <!DOCTYPE html>
 <html>
   <head>
     <title>
       Test decodeAudioData promises
     </title>
     <script src="../../resources/testharness.js"></script>
     <script src="../../resources/testharnessreport.js"></script>
     <script src="../resources/audit.js"></script>
   </head>
   <body>
     <script id="layout-test-code">
       // The functionality of decodeAudioData() is orthogonal to the type and
       // the state of AudioContext. So we use the online context here and any
       // resampling of the file is okay for this test.
       let context = new AudioContext();

       // Test file URLs.
       let validAudioFileUrl = '../resources/media/24bit-44khz.wav';
       let invalidAudioFileUrl = '../resources/media/invalid-audio-file.txt';

       // Global storage for array buffers from XHR.
       let validArrayBuffer;
       let invalidArrayBuffer;

       // Decoded data from validAudioFile.
       let referenceDecodedAudioBuffer;

       let audit = Audit.createTaskRunner();

       // Preload ArrayBuffer and the reference AudioBuffer from URLs.
       audit.define('preload-arraybuffer', (task, should) => {
         Promise
             .all([
               should(
                   Audit.loadFileFromUrl(validAudioFileUrl),
                   'Loading valid audio file')
                   .beResolved(),
               should(
                   Audit.loadFileFromUrl(invalidAudioFileUrl),
                   'loading invalid audio file')
                   .beResolved()
             ])
             .then((arrayBuffers) => {
               validArrayBuffer = arrayBuffers[0];
               invalidArrayBuffer = arrayBuffers[1];
             })
             .then(() => task.done());
       });

       // Decode a valid encoded file and verify that the promise succeeds
       // correctly.
       audit.define('decode-valid-file', (task, should) => {
         // Note that the order of completion for each promise is undefined and
         // we do not care about it in this test.
         Promise
             .all([
               // Do not use the original arrayBuffers for decoding; decode a
               // copy because decodeAudioData will detach the buffers.
               should(
                   context.decodeAudioData(validArrayBuffer.slice(0)),
                   'Decoding a valid audio file')
                   .beResolved()
                   .then(buffer => referenceDecodedAudioBuffer = buffer),
               should(
                   context.decodeAudioData(invalidArrayBuffer.slice(0)),
                   'Decoding an invalid audio file')
                   .beRejectedWith('EncodingError'),
               should(context.decodeAudioData(null), 'Decoding null AudioBuffer')
                   .beRejected()
             ])
             .then(() => task.done());
       });

       // Decode a valid file and verify that the promise is fulfilled and the
       // successCallback is invoked and both have identical decoded audio
       // buffers.
       audit.define('promise-and-success-callback', (task, should) => {
         let bufferByCallback;
         let bufferByPromise;

         // Use one callback for success and error. |callbackArg| is a parameter
         // for callback functions; it is a decoded audio buffer for success case
         // and an error object for failure case.
         let successOrErrorCallback = (callbackArg) => {
           should(
               callbackArg instanceof AudioBuffer,
               'Decoding valid file by callback function')
               .message(
                   'successCallback invoked correctly',
                   'errorCallback incorrectly invoked with ' + callbackArg);
           bufferByCallback = callbackArg;
         };

         // Step 1: Decode a file with callback functions.
         let step1 = context.decodeAudioData(
             validArrayBuffer.slice(), successOrErrorCallback,
             successOrErrorCallback);

         // Step 2: Then decode a file with promise pattern.
         let step2 = should(step1, 'Decoding a file via promise')
                         .beResolved()
                         .then((audioBuffer) => {
                           bufferByPromise = audioBuffer;
                         });

         // Step 3: compare two buffers from Step 1 and Step 2.
         step2.then(() => {
           should(
               bufferByCallback === bufferByPromise,
               'Two buffers decoded by callback function and promise')
               .message('are identical', 'are different');
           task.done();
         });
       });

       // Decode an invalid file and verify that the promise is rejected and the
       // errorCallback is invoked.
       audit.define('promise-and-error-callback', (task, should) => {
         let successOrErrorCallback = (callbackArg) => {
           should(
               callbackArg instanceof Error,
               'Decoding invalid file with promise and callback:')
               .message(
                   'errorCallback invoked correctly with ' + callbackArg,
                   'successCallback should not have invoked');
         };

         let decodeAudioDataPromise = context.decodeAudioData(
             invalidArrayBuffer.slice(), successOrErrorCallback,
             successOrErrorCallback);

         should(decodeAudioDataPromise, 'decodeAudioData promise')
             .beRejected('EncodingError')
             .then(() => task.done());
       });

       // decodeAudioData() should be functional even after the associated
       // context is closed.
       audit.define('decoding-on-closed-context', (task, should) => {
         // Use one handler for resolve and reject. |promiseArg| is a parameter
         // for handlers; it is a decoded audio buffer for success case and an
         // error object for failure case.
         let resolveOrReject = (promiseArg) => {
           let didDecode = promiseArg instanceof AudioBuffer;

           if (didDecode) {
             // Compare two decoded AudioBuffers.
             let actual = promiseArg;
             let expected = referenceDecodedAudioBuffer;
             should(actual.length, 'Decoded buffer length (frames)')
                 .beEqualTo(expected.length);
             should(actual.duration, 'Decoded buffer duration (sec)')
                 .beEqualTo(expected.duration);
             should(actual.sampleRate, 'Decoded buffer sample rate (Hz)')
                 .beEqualTo(expected.sampleRate);
             should(
                 actual.numberOfChannels, 'Number of channels in decoded buffer')
                 .beEqualTo(expected.numberOfChannels);
             for (let c = 0; c < expected.numberOfChannels; ++c) {
               let actualChannelData = actual.getChannelData(c);
               let expectedChannelData = expected.getChannelData(c);
               should(actualChannelData, 'Decoded buffer channel #' + c)
                   .beEqualToArray(
                       expectedChannelData, 'the expected channel #' + c);
             }
             should(task.state, 'The buffer')
                 .message(
                     'correctly decoded after the context has been closed',
                     'decoding succeeded but the data is incorrect');
           }

           should(
               didDecode, 'Decoding ArrayBuffer after context has been closed')
               .message('completed successfully', 'failed : ' + promiseArg);
         };

         let onlineContext = new AudioContext();
         onlineContext.close()
             .then(() => {
               return context.decodeAudioData(validArrayBuffer);
             })
             .then(resolveOrReject, resolveOrReject)
             .then(() => {
               task.done();
             });
       });

       audit.run();
     </script>
   </body>
 </html>
	<!DOCTYPE html>
	<html>
	<head>
	<title>
	Test decodeAudioData promises
	</title>
	<script src="../../resources/testharness.js"></script>
	<script src="../../resources/testharnessreport.js"></script>
	<script src="../resources/audit.js"></script>
	</head>
	<body>
	<script id="layout-test-code">
	// The functionality of decodeAudioData() is orthogonal to the type and
	// the state of AudioContext. So we use the online context here and any
	// resampling of the file is okay for this test.
	let context = new AudioContext();

	// Test file URLs.
	let validAudioFileUrl = '../resources/media/24bit-44khz.wav';
	let invalidAudioFileUrl = '../resources/media/invalid-audio-file.txt';

	// Global storage for array buffers from XHR.
	let validArrayBuffer;
	let invalidArrayBuffer;

	// Decoded data from validAudioFile.
	let referenceDecodedAudioBuffer;

	let audit = Audit.createTaskRunner();

	// Preload ArrayBuffer and the reference AudioBuffer from URLs.
	audit.define('preload-arraybuffer', (task, should) => {
	Promise
	.all([
	should(
	Audit.loadFileFromUrl(validAudioFileUrl),
	'Loading valid audio file')
	.beResolved(),
	should(
	Audit.loadFileFromUrl(invalidAudioFileUrl),
	'loading invalid audio file')
	.beResolved()
	])
	.then((arrayBuffers) => {
	validArrayBuffer = arrayBuffers[0];
	invalidArrayBuffer = arrayBuffers[1];
	})
	.then(() => task.done());
	});

	// Decode a valid encoded file and verify that the promise succeeds
	// correctly.
	audit.define('decode-valid-file', (task, should) => {
	// Note that the order of completion for each promise is undefined and
	// we do not care about it in this test.
	Promise
	.all([
	// Do not use the original arrayBuffers for decoding; decode a
	// copy because decodeAudioData will detach the buffers.
	should(
	context.decodeAudioData(validArrayBuffer.slice(0)),
	'Decoding a valid audio file')
	.beResolved()
	.then(buffer => referenceDecodedAudioBuffer = buffer),
	should(
	context.decodeAudioData(invalidArrayBuffer.slice(0)),
	'Decoding an invalid audio file')
	.beRejectedWith('EncodingError'),
	should(context.decodeAudioData(null), 'Decoding null AudioBuffer')
	.beRejected()
	])
	.then(() => task.done());
	});

	// Decode a valid file and verify that the promise is fulfilled and the
	// successCallback is invoked and both have identical decoded audio
	// buffers.
	audit.define('promise-and-success-callback', (task, should) => {
	let bufferByCallback;
	let bufferByPromise;

	// Use one callback for success and error. \|callbackArg\| is a parameter
	// for callback functions; it is a decoded audio buffer for success case
	// and an error object for failure case.
	let successOrErrorCallback = (callbackArg) => {
	should(
	callbackArg instanceof AudioBuffer,
	'Decoding valid file by callback function')
	.message(
	'successCallback invoked correctly',
	'errorCallback incorrectly invoked with ' + callbackArg);
	bufferByCallback = callbackArg;
	};

	// Step 1: Decode a file with callback functions.
	let step1 = context.decodeAudioData(
	validArrayBuffer.slice(), successOrErrorCallback,
	successOrErrorCallback);

	// Step 2: Then decode a file with promise pattern.
	let step2 = should(step1, 'Decoding a file via promise')
	.beResolved()
	.then((audioBuffer) => {
	bufferByPromise = audioBuffer;
	});

	// Step 3: compare two buffers from Step 1 and Step 2.
	step2.then(() => {
	should(
	bufferByCallback === bufferByPromise,
	'Two buffers decoded by callback function and promise')
	.message('are identical', 'are different');
	task.done();
	});
	});

	// Decode an invalid file and verify that the promise is rejected and the
	// errorCallback is invoked.
	audit.define('promise-and-error-callback', (task, should) => {
	let successOrErrorCallback = (callbackArg) => {
	should(
	callbackArg instanceof Error,
	'Decoding invalid file with promise and callback:')
	.message(
	'errorCallback invoked correctly with ' + callbackArg,
	'successCallback should not have invoked');
	};

	let decodeAudioDataPromise = context.decodeAudioData(
	invalidArrayBuffer.slice(), successOrErrorCallback,
	successOrErrorCallback);

	should(decodeAudioDataPromise, 'decodeAudioData promise')
	.beRejected('EncodingError')
	.then(() => task.done());
	});

	// decodeAudioData() should be functional even after the associated
	// context is closed.
	audit.define('decoding-on-closed-context', (task, should) => {
	// Use one handler for resolve and reject. \|promiseArg\| is a parameter
	// for handlers; it is a decoded audio buffer for success case and an
	// error object for failure case.
	let resolveOrReject = (promiseArg) => {
	let didDecode = promiseArg instanceof AudioBuffer;

	if (didDecode) {
	// Compare two decoded AudioBuffers.
	let actual = promiseArg;
	let expected = referenceDecodedAudioBuffer;
	should(actual.length, 'Decoded buffer length (frames)')
	.beEqualTo(expected.length);
	should(actual.duration, 'Decoded buffer duration (sec)')
	.beEqualTo(expected.duration);
	should(actual.sampleRate, 'Decoded buffer sample rate (Hz)')
	.beEqualTo(expected.sampleRate);
	should(
	actual.numberOfChannels, 'Number of channels in decoded buffer')
	.beEqualTo(expected.numberOfChannels);
	for (let c = 0; c < expected.numberOfChannels; ++c) {
	let actualChannelData = actual.getChannelData(c);
	let expectedChannelData = expected.getChannelData(c);
	should(actualChannelData, 'Decoded buffer channel #' + c)
	.beEqualToArray(
	expectedChannelData, 'the expected channel #' + c);
	}
	should(task.state, 'The buffer')
	.message(
	'correctly decoded after the context has been closed',
	'decoding succeeded but the data is incorrect');
	}

	should(
	didDecode, 'Decoding ArrayBuffer after context has been closed')
	.message('completed successfully', 'failed : ' + promiseArg);
	};

	let onlineContext = new AudioContext();
	onlineContext.close()
	.then(() => {
	return context.decodeAudioData(validArrayBuffer);
	})
	.then(resolveOrReject, resolveOrReject)
	.then(() => {
	task.done();
	});
	});

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