tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

language-model-create.tentative.https.window.js (4785B)

      1 // META: title=Language Model Create
      2 // META: script=/resources/testdriver.js
      3 // META: script=../resources/util.js
      4 // META: timeout=long
      5 
      6 'use strict';
      7 
      8 promise_test(async t => {
      9  await ensureLanguageModel();
     10 }, 'Ensure sessions can be created');
     11 
     12 promise_test(async t => {
     13  let session = await createLanguageModel();
     14  assert_true(session instanceof LanguageModel);
     15 
     16  assert_equals(typeof session.prompt, 'function');
     17  assert_equals(typeof session.promptStreaming, 'function');
     18  assert_equals(typeof session.append, 'function');
     19  assert_equals(typeof session.measureInputUsage, 'function');
     20  assert_equals(typeof session.clone, 'function');
     21  assert_equals(typeof session.destroy, 'function');
     22 
     23  assert_equals(typeof session.inputUsage, 'number');
     24  assert_equals(typeof session.inputQuota, 'number');
     25  assert_equals(typeof session.topK, 'number');
     26  assert_equals(typeof session.temperature, 'number');
     27 
     28  assert_equals(typeof session.onquotaoverflow, 'object');
     29 }, 'LanguageModel.create() returns a valid object with default options');
     30 
     31 promise_test(async t => {
     32  await testMonitor(createLanguageModel);
     33 }, 'LanguageModel.create() notifies its monitor on downloadprogress');
     34 
     35 promise_test(async t => {
     36  await testCreateMonitorWithAbort(t, createLanguageModel);
     37 }, 'Progress events are not emitted after aborted.');
     38 
     39 promise_test(async t => {
     40  let session = await createLanguageModel({ topK: 3, temperature: 0.6 });
     41  assert_true(!!session);
     42 }, 'Create with topK and temperature');
     43 
     44 promise_test(async t => {
     45  let result = createLanguageModel({ topK: 3 });
     46  await promise_rejects_dom(
     47      t, 'NotSupportedError', result,
     48      'Initializing a new session must either specify both topK and temperature, or neither of them.');
     49 }, 'Create with only topK should fail');
     50 
     51 promise_test(async t => {
     52  let result = createLanguageModel({ temperature: 0.5 });
     53  await promise_rejects_dom(
     54      t, 'NotSupportedError', result,
     55      'Initializing a new session must either specify both topK and temperature, or neither of them.');
     56 }, 'Create with only temperature should fail');
     57 
     58 promise_test(async t => {
     59  let result = createLanguageModel({ topK: 3, temperature: -0.5 });
     60  await promise_rejects_js(t, RangeError, result);
     61 }, 'Create with negative temperature should fail');
     62 
     63 promise_test(async t => {
     64  let result = createLanguageModel({ topK: 0, temperature: 0.5 });
     65  await promise_rejects_js(t, RangeError, result);
     66 }, 'Create with zero topK should fail');
     67 
     68 promise_test(async t => {
     69  let result = createLanguageModel({ topK: -2, temperature: 0.5 });
     70  await promise_rejects_js(t, RangeError, result);
     71 }, 'Create with negative topK should fail');
     72 
     73 promise_test(async t => {
     74  let session = await createLanguageModel({ topK: 1.5, temperature: 0.5 });
     75  assert_true(!!session);
     76  assert_equals(session.topK, 1);
     77 }, 'Create with fractional topK should be rounded down');
     78 
     79 promise_test(async t => {
     80  let session = await createLanguageModel({
     81    initialPrompts: [
     82      {role: 'system', content: 'you are a robot'},
     83      {role: 'user', content: 'hello'}, {role: 'assistant', content: 'hello'}
     84    ]
     85  });
     86  assert_true(!!session);
     87 }, 'Create with initialPrompts');
     88 
     89 promise_test(async t => {
     90  let session = await createLanguageModel({initialPrompts: []});
     91  assert_true(!!session);
     92 }, 'Create with empty initialPrompts');
     93 
     94 promise_test(async t => {
     95  let session = await createLanguageModel({
     96    initialPrompts: [
     97      {role: 'user', content: 'hello'}, {role: 'assistant', content: 'hello'}
     98    ]
     99  });
    100  assert_true(!!session);
    101 }, 'Create with initialPrompts without system role');
    102 
    103 promise_test(async t => {
    104  let result = createLanguageModel({
    105    initialPrompts: [
    106      {role: 'user', content: 'hello'}, {role: 'assistant', content: 'hello'},
    107      {role: 'system', content: 'you are a robot'}
    108    ]
    109  });
    110  await promise_rejects_js(t, TypeError, result);
    111 }, 'Create with system role not ordered first should fail');
    112 
    113 promise_test(async t => {
    114  let result = createLanguageModel({
    115    initialPrompts: [
    116      {role: 'system', content: 'you are a robot'},
    117      {role: 'system', content: 'you are a kitten'},
    118      {role: 'user', content: 'hello'}, {role: 'assistant', content: 'hello'}
    119    ]
    120  });
    121  await promise_rejects_js(t, TypeError, result);
    122 }, 'Create multiple system role entries should fail');
    123 
    124 promise_test(async (t) => {
    125  return promise_rejects_js(t, RangeError, LanguageModel.create({
    126    expectedInputs: [{type: 'text', languages: ['en-abc-invalid']}]
    127  }));
    128 }, 'LanguageModel.create() rejects when given invalid language tags');
    129 
    130 promise_test(async (t) => {
    131  let session = await LanguageModel.create(
    132      {expectedInputs: [{type: 'text', languages: ['EN']}]});
    133  assert_true(!!session);
    134 }, 'LanguageModel.create() canonicalizes language tags');