speech-api/SpeechRecognition-availableOnDevice.https.html - external/w3c/web-platform-tests - Git at Google

 <!DOCTYPE html>
 <title>SpeechRecognition available</title>
 <script src="/resources/testharness.js"></script>
 <script src="/resources/testharnessreport.js"></script>
 <script>
 promise_test(async (t) => {
   const options = { langs: ["en-US", "fr-FR"], processLocally: true };
   window.SpeechRecognition = window.SpeechRecognition ||
     window.webkitSpeechRecognition;

   // Test that it returns a promise.
   const resultPromise = SpeechRecognition.available(options);
   assert_true(
     resultPromise instanceof Promise,
     "available should return a Promise."
   );

   // Verify the resolved value is a string.
   const result = await resultPromise;
   assert_true(
     typeof result === "string",
     "The resolved value of the available promise should be a string."
   );

   assert_true(
     result === "unavailable" || result === "downloadable" ||
     result === "downloading" || result === "available",
     "The resolved value of the available promise should be a " +
     "valid value."
   );
 }, "SpeechRecognition.available resolves with a string value for on-device.");

 promise_test(async (t) => {
   const iframe = document.createElement("iframe");
   document.body.appendChild(iframe);
   const frameWindow = iframe.contentWindow;
   const frameDOMException = frameWindow.DOMException;
   const frameSpeechRecognition =
     frameWindow.SpeechRecognition || frameWindow.webkitSpeechRecognition;

   const options = { langs: ["en-US"], processLocally: true };
   iframe.remove();
   await promise_rejects_dom(
     t,
     "InvalidStateError",
     frameDOMException,
     frameSpeechRecognition.available(options),
   );
 }, "SpeechRecognition.available rejects in a detached context for on-device.");

 promise_test(async (t) => {
   const iframe = document.createElement("iframe");
   // This policy should make the on-device speech recognition
   // feature unavailable.
   iframe.setAttribute("allow", "on-device-speech-recognition 'none'");
   document.body.appendChild(iframe);
   t.add_cleanup(() => iframe.remove());

   await new Promise(resolve => {
     if (iframe.contentWindow &&
         iframe.contentWindow.document.readyState === 'complete') {
       resolve();
     } else {
       iframe.onload = resolve;
     }
   });

   const frameWindow = iframe.contentWindow;
   const frameSpeechRecognition = frameWindow.SpeechRecognition ||
     frameWindow.webkitSpeechRecognition;

   assert_true(!!frameSpeechRecognition,
     "SpeechRecognition should exist in iframe.");
   assert_true(!!frameSpeechRecognition.available,
     "available method should exist on SpeechRecognition in iframe.");

   const options = { langs: ["en-US"], processLocally: true };
   // Call available and expect it to resolve to "unavailable".
   const availabilityStatus =
     await frameSpeechRecognition.available(options);
   assert_equals(availabilityStatus, "unavailable",
     "available should resolve to 'unavailable' if " +
     "'on-device-speech-recognition' Permission Policy is 'none'."
   );
 }, "SpeechRecognition.available resolves to 'unavailable' for on-device if " +
   "'on-device-speech-recognition' Permission Policy is 'none'.");

 promise_test(async (t) => {
   const html = `
     <!DOCTYPE html>
     <script>
       window.addEventListener('message', async (event) => {
         // Ensure we only process the message intended to trigger the test.
         if (event.data !== "runTestCallAvailable") return;

         try {
           const SpeechRecognition = window.SpeechRecognition ||
                                     window.webkitSpeechRecognition;
           if (!SpeechRecognition || !SpeechRecognition.available) {
             parent.postMessage({
               type: "error", // Use "error" for API not found or other issues.
               name: "NotSupportedError",
               message: "SpeechRecognition.available API not " +
                        "available in iframe"
             }, "*");
             return;
           }

           const options = { langs: ["en-US"], processLocally: true };
           // Call available and post its resolution.
           const availabilityStatus =
               await SpeechRecognition.available(options);
           parent.postMessage(
               { type: "resolution", result: availabilityStatus },
               "*"
           ); // Post the string status
         } catch (err) {
           // Catch any unexpected errors during the API call or message post.
           parent.postMessage({
             type: "error",
             name: err.name,
             message: err.message
           }, "*");
         }
       });
     <\/script>
   `;

   const blob = new Blob([html], { type: "text/html" });
   const blobUrl = URL.createObjectURL(blob);
   // Important: Revoke the blob URL after the test to free up resources.
   t.add_cleanup(() => URL.revokeObjectURL(blobUrl));

   const iframe = document.createElement("iframe");
   iframe.src = blobUrl;
   // Sandboxing with "allow-scripts" is needed for the script inside
   // the iframe to run.
   // The cross-origin nature is primarily due to the blob URL's origin being
   // treated as distinct from the parent page's origin for security
   // purposes.
   iframe.setAttribute("sandbox", "allow-scripts");
   document.body.appendChild(iframe);
   t.add_cleanup(() => iframe.remove());

   await new Promise(resolve => iframe.onload = resolve);

   const testResult = await new Promise((resolve, reject) => {
     const timeoutId = t.step_timeout(() => {
       reject(new Error("Test timed out waiting for message from iframe. " +
                        "Ensure iframe script is correctly posting a message."));
     }, 6000); // 6-second timeout

     window.addEventListener("message", t.step_func((event) => {
       // Basic check to ensure the message is from our iframe.
       if (event.source !== iframe.contentWindow) return;
       clearTimeout(timeoutId);
       resolve(event.data);
     }));

     // Send a distinct message to the iframe to trigger its test logic.
     iframe.contentWindow.postMessage("runTestCallAvailable", "*");
   });

   // Check if the iframe's script reported an error (e.g., API not found).
   if (testResult.type === "error") {
     const errorMessage =
         `Iframe reported an error: ${testResult.name} - ` +
         testResult.message;
     assert_unreached(errorMessage);
   }

   assert_equals(
     testResult.type,
     "resolution",
     "The call from the iframe should resolve and post a 'resolution' " +
     "message."
   );
   assert_equals(
     testResult.result, // Expecting the string "unavailable".
     "unavailable",
     "available should resolve to 'unavailable' for on-device in a cross-origin " +
     "iframe."
   );
 }, "SpeechRecognition.available should resolve to 'unavailable' for on-device " +
    "in a cross-origin iframe.");
 </script>
	<!DOCTYPE html>
	<title>SpeechRecognition available</title>
	<script src="/resources/testharness.js"></script>
	<script src="/resources/testharnessreport.js"></script>
	<script>
	promise_test(async (t) => {
	const options = { langs: ["en-US", "fr-FR"], processLocally: true };
	window.SpeechRecognition = window.SpeechRecognition \|\|
	window.webkitSpeechRecognition;

	// Test that it returns a promise.
	const resultPromise = SpeechRecognition.available(options);
	assert_true(
	resultPromise instanceof Promise,
	"available should return a Promise."
	);

	// Verify the resolved value is a string.
	const result = await resultPromise;
	assert_true(
	typeof result === "string",
	"The resolved value of the available promise should be a string."
	);

	assert_true(
	result === "unavailable" \|\| result === "downloadable" \|\|
	result === "downloading" \|\| result === "available",
	"The resolved value of the available promise should be a " +
	"valid value."
	);
	}, "SpeechRecognition.available resolves with a string value for on-device.");

	promise_test(async (t) => {
	const iframe = document.createElement("iframe");
	document.body.appendChild(iframe);
	const frameWindow = iframe.contentWindow;
	const frameDOMException = frameWindow.DOMException;
	const frameSpeechRecognition =
	frameWindow.SpeechRecognition \|\| frameWindow.webkitSpeechRecognition;

	const options = { langs: ["en-US"], processLocally: true };
	iframe.remove();
	await promise_rejects_dom(
	t,
	"InvalidStateError",
	frameDOMException,
	frameSpeechRecognition.available(options),
	);
	}, "SpeechRecognition.available rejects in a detached context for on-device.");

	promise_test(async (t) => {
	const iframe = document.createElement("iframe");
	// This policy should make the on-device speech recognition
	// feature unavailable.
	iframe.setAttribute("allow", "on-device-speech-recognition 'none'");
	document.body.appendChild(iframe);
	t.add_cleanup(() => iframe.remove());

	await new Promise(resolve => {
	if (iframe.contentWindow &&
	iframe.contentWindow.document.readyState === 'complete') {
	resolve();
	} else {
	iframe.onload = resolve;
	}
	});

	const frameWindow = iframe.contentWindow;
	const frameSpeechRecognition = frameWindow.SpeechRecognition \|\|
	frameWindow.webkitSpeechRecognition;

	assert_true(!!frameSpeechRecognition,
	"SpeechRecognition should exist in iframe.");
	assert_true(!!frameSpeechRecognition.available,
	"available method should exist on SpeechRecognition in iframe.");

	const options = { langs: ["en-US"], processLocally: true };
	// Call available and expect it to resolve to "unavailable".
	const availabilityStatus =
	await frameSpeechRecognition.available(options);
	assert_equals(availabilityStatus, "unavailable",
	"available should resolve to 'unavailable' if " +
	"'on-device-speech-recognition' Permission Policy is 'none'."
	);
	}, "SpeechRecognition.available resolves to 'unavailable' for on-device if " +
	"'on-device-speech-recognition' Permission Policy is 'none'.");

	promise_test(async (t) => {
	const html = `
	<!DOCTYPE html>
	<script>
	window.addEventListener('message', async (event) => {
	// Ensure we only process the message intended to trigger the test.
	if (event.data !== "runTestCallAvailable") return;

	try {
	const SpeechRecognition = window.SpeechRecognition \|\|
	window.webkitSpeechRecognition;
	if (!SpeechRecognition \|\| !SpeechRecognition.available) {
	parent.postMessage({
	type: "error", // Use "error" for API not found or other issues.
	name: "NotSupportedError",
	message: "SpeechRecognition.available API not " +
	"available in iframe"
	}, "*");
	return;
	}

	const options = { langs: ["en-US"], processLocally: true };
	// Call available and post its resolution.
	const availabilityStatus =
	await SpeechRecognition.available(options);
	parent.postMessage(
	{ type: "resolution", result: availabilityStatus },
	"*"
	); // Post the string status
	} catch (err) {
	// Catch any unexpected errors during the API call or message post.
	parent.postMessage({
	type: "error",
	name: err.name,
	message: err.message
	}, "*");
	}
	});
	<\/script>
	`;

	const blob = new Blob([html], { type: "text/html" });
	const blobUrl = URL.createObjectURL(blob);
	// Important: Revoke the blob URL after the test to free up resources.
	t.add_cleanup(() => URL.revokeObjectURL(blobUrl));

	const iframe = document.createElement("iframe");
	iframe.src = blobUrl;
	// Sandboxing with "allow-scripts" is needed for the script inside
	// the iframe to run.
	// The cross-origin nature is primarily due to the blob URL's origin being
	// treated as distinct from the parent page's origin for security
	// purposes.
	iframe.setAttribute("sandbox", "allow-scripts");
	document.body.appendChild(iframe);
	t.add_cleanup(() => iframe.remove());

	await new Promise(resolve => iframe.onload = resolve);

	const testResult = await new Promise((resolve, reject) => {
	const timeoutId = t.step_timeout(() => {
	reject(new Error("Test timed out waiting for message from iframe. " +
	"Ensure iframe script is correctly posting a message."));
	}, 6000); // 6-second timeout

	window.addEventListener("message", t.step_func((event) => {
	// Basic check to ensure the message is from our iframe.
	if (event.source !== iframe.contentWindow) return;
	clearTimeout(timeoutId);
	resolve(event.data);
	}));

	// Send a distinct message to the iframe to trigger its test logic.
	iframe.contentWindow.postMessage("runTestCallAvailable", "*");
	});

	// Check if the iframe's script reported an error (e.g., API not found).
	if (testResult.type === "error") {
	const errorMessage =
	`Iframe reported an error: ${testResult.name} - ` +
	testResult.message;
	assert_unreached(errorMessage);
	}

	assert_equals(
	testResult.type,
	"resolution",
	"The call from the iframe should resolve and post a 'resolution' " +
	"message."
	);
	assert_equals(
	testResult.result, // Expecting the string "unavailable".
	"unavailable",
	"available should resolve to 'unavailable' for on-device in a cross-origin " +
	"iframe."
	);
	}, "SpeechRecognition.available should resolve to 'unavailable' for on-device " +
	"in a cross-origin iframe.");
	</script>