detector.https.window.js (6323B)
1 // META: title=Detect english 2 // META: global=window 3 // META: timeout=long 4 // META: script=resources/util.js 5 // META: script=/resources/testdriver.js 6 // META: script=../resources/util.js 7 // META: script=../resources/locale-util.js 8 9 'use strict'; 10 11 // TODO(crbug.com/390246212): Support model state controls for WPTs. 12 promise_test(async t => { 13 // Create requires user activation when availability is 'downloadable'. 14 assert_implements_optional(await LanguageDetector.availability() == 'downloadable'); 15 assert_false(navigator.userActivation.isActive); 16 await promise_rejects_dom(t, 'NotAllowedError', LanguageDetector.create()); 17 await test_driver.bless('LanguageDetector.create', LanguageDetector.create); 18 // User activation is not consumed by the create call. 19 assert_true(navigator.userActivation.isActive); 20 consumeTransientUserActivation(); 21 22 // Create does not require transient user activation. 23 assert_equals(await LanguageDetector.availability(), 'available'); 24 assert_false(navigator.userActivation.isActive); 25 await LanguageDetector.create(); 26 }, 'Create requires sticky user activation when availability is "downloadable"'); 27 28 promise_test(async t => { 29 const detector = await createLanguageDetector(); 30 const results = await detector.detect(kTestPrompt); 31 32 // must at least have the 'und' result. 33 assert_greater_than_equal(results.length, 1); 34 35 // The last result should be 'und'. 36 const undResult = results.pop(); 37 assert_equals(undResult.detectedLanguage, 'und'); 38 assert_greater_than(undResult.confidence, 0); 39 40 let total_confidence_without_und = 0; 41 let last_confidence = 1; 42 for (const {detectedLanguage, confidence} of results) { 43 // All results must be in canonical form. 44 assert_is_canonical(detectedLanguage); 45 46 assert_greater_than(confidence, 0); 47 assert_greater_than(confidence, undResult.confidence); 48 49 total_confidence_without_und += confidence; 50 51 // Except for 'und', results must be from high to low confidence. 52 assert_greater_than_equal(last_confidence, confidence); 53 last_confidence = confidence; 54 } 55 56 // If we have non-und results, their confidences, excluding the last non-'und' 57 // result, must be less than 0.99. 58 if (results.length > 0) { 59 assert_less_than( 60 total_confidence_without_und - results.at(-1).confidence, 0.99); 61 } 62 63 // Confidences, including 'und', should be less than or equal to one. 64 assert_less_than_equal( 65 total_confidence_without_und + undResult.confidence, 1); 66 }, 'LanguageDetector.detect() returns valid results'); 67 68 promise_test(async t => { 69 await testCreateMonitorCallbackThrowsError(t, createLanguageDetector); 70 }, 'If monitor throws an error, LanguageDetector.create() rejects with that error'); 71 72 promise_test(async t => { 73 testMonitor(createLanguageDetector); 74 }, 'LanguageDetector.create() notifies its monitor on downloadprogress'); 75 76 promise_test(async t => { 77 const controller = new AbortController(); 78 controller.abort(); 79 80 const createPromise = createLanguageDetector({signal: controller.signal}); 81 82 await promise_rejects_dom(t, 'AbortError', createPromise); 83 }, 'LanguageDetector.create() call with an aborted signal.'); 84 85 promise_test(async t => { 86 await testAbortPromise(t, signal => { 87 return createLanguageDetector({signal}); 88 }); 89 }, 'Aborting createLanguageDetector().'); 90 91 promise_test(async t => { 92 await testDestroy(t, createLanguageDetector, {}, [ 93 detector => detector.detect(kTestPrompt), 94 detector => detector.measureInputUsage(kTestPrompt), 95 ]); 96 }, 'Calling LanguageDetector.destroy() aborts calls to detect and measureInputUsage.'); 97 98 promise_test(async t => { 99 await testCreateAbort(t, createLanguageDetector, {}, [ 100 detector => detector.detect(kTestPrompt), 101 detector => detector.measureInputUsage(kTestPrompt), 102 ]); 103 }, 'LanguageDetector.create()\'s abort signal destroys its LanguageDetector after creation.'); 104 105 promise_test(async t => { 106 const controller = new AbortController(); 107 controller.abort(); 108 109 const detector = await createLanguageDetector(); 110 const detectPromise = 111 detector.detect(kTestPrompt, { signal: controller.signal }); 112 113 await promise_rejects_dom(t, 'AbortError', detectPromise); 114 }, 'LanguageDetector.detect() call with an aborted signal.'); 115 116 promise_test(async t => { 117 const detector = await createLanguageDetector(); 118 await testAbortPromise(t, signal => { 119 return detector.detect(kTestPrompt, { signal }); 120 }); 121 }, 'Aborting LanguageDetector.detect().'); 122 123 promise_test(async t => { 124 const detector = await createLanguageDetector(); 125 126 const text = 'Hello world!'; 127 const largeText = text.repeat(10000); 128 const inputUsage = await detector.measureInputUsage(largeText); 129 130 assert_greater_than_equal(detector.inputQuota, 0); 131 assert_greater_than_equal(inputUsage, 0); 132 133 const detectPromise = detector.detect(text); 134 135 if (inputUsage >= detector.inputQuota) { 136 await promise_rejects_quotaexceedederror(t, detectPromise, requested => requested !== null, detector.inputQuota); 137 } else { 138 await detectPromise; 139 } 140 }, 'LanguageDetector.measureInputUsage() and inputQuota basic usage.'); 141 142 promise_test(async t => { 143 const controller = new AbortController(); 144 controller.abort(); 145 146 const detector = await createLanguageDetector(); 147 const measureInputUsagePromise = 148 detector.measureInputUsage(kTestPrompt, { signal: controller.signal }); 149 150 await promise_rejects_dom(t, 'AbortError', measureInputUsagePromise); 151 }, 'LanguageDetector.measureInputUsage() call with an aborted signal.'); 152 153 promise_test(async t => { 154 const detector = await createLanguageDetector(); 155 await testAbortPromise(t, signal => { 156 return detector.measureInputUsage(kTestPrompt, { signal }); 157 }); 158 }, 'Aborting LanguageDetector.measureInputUsage().'); 159 160 promise_test(async () => { 161 const detector = await createLanguageDetector({expectedInputLanguages: []}); 162 assert_equals(detector.expectedInputLanguages, null); 163 }, 'Creating LanguageDetector with empty expectedInputLanguages array'); 164 165 promise_test(async () => { 166 const detector = await createLanguageDetector(); 167 assert_equals(detector.expectedInputLanguages, null); 168 }, 'Creating LanguageDetector without expectedInputLanguages'); 169 170 promise_test(async t => { 171 await testCreateMonitorWithAbort(t, createLanguageDetector); 172 }, 'Progress events are not emitted after aborted.');