tor-browser

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

compute_pressure_basic.https.window.js (4587B)

      1 // META: timeout=long
      2 // META: variant=?globalScope=window
      3 // META: variant=?globalScope=dedicated_worker
      4 // META: script=/resources/testdriver.js
      5 // META: script=/resources/testdriver-vendor.js
      6 // META: script=/common/utils.js
      7 // META: script=/common/dispatcher/dispatcher.js
      8 // META: script=./resources/common.js
      9 
     10 'use strict';
     11 
     12 pressure_test(async (t) => {
     13  const observer = new PressureObserver(() => {
     14    assert_unreached('The observer callback should not be called');
     15  });
     16 
     17  await create_virtual_pressure_source('cpu', {supported: false});
     18  t.add_cleanup(async () => {
     19    await remove_virtual_pressure_source('cpu');
     20  });
     21  return promise_rejects_dom(t, 'NotSupportedError', observer.observe('cpu'));
     22 }, 'Return NotSupportedError when calling observer()');
     23 
     24 pressure_test(async (t) => {
     25  await create_virtual_pressure_source('cpu');
     26  t.add_cleanup(async () => {
     27    await remove_virtual_pressure_source('cpu');
     28  });
     29 
     30  const changes = await new Promise((resolve, reject) => {
     31    const observer = new PressureObserver(resolve);
     32    t.add_cleanup(() => observer.disconnect());
     33    observer.observe('cpu').catch(reject);
     34    update_virtual_pressure_source('cpu', 'critical', 0.5).catch(reject);
     35  });
     36  assert_equals(1, changes.length);
     37  assert_equals(changes[0].state, 'critical');
     38  assert_equals(changes[0].source, 'cpu');
     39  assert_equals(typeof changes[0].time, 'number');
     40  assert_equals(typeof changes[0].ownContributionEstimate, 'number');
     41  assert_equals(changes[0].ownContributionEstimate, 0.5);
     42 }, 'Basic functionality test');
     43 
     44 pressure_test(async (t) => {
     45  await create_virtual_pressure_source('cpu');
     46  t.add_cleanup(async () => {
     47    await remove_virtual_pressure_source('cpu');
     48  });
     49 
     50  const changes = await new Promise((resolve, reject) => {
     51    const observer = new PressureObserver(resolve);
     52    t.add_cleanup(() => observer.disconnect());
     53    observer.observe('cpu').catch(reject);
     54    update_virtual_pressure_source('cpu', 'critical').catch(reject);
     55  });
     56  assert_equals(1, changes.length);
     57  assert_equals(changes[0].state, 'critical');
     58  assert_equals(changes[0].source, 'cpu');
     59  assert_equals(typeof changes[0].time, 'number');
     60  assert_equals(changes[0].ownContributionEstimate, null);
     61 }, 'Basic functionality test with no ownContributionEstimate');
     62 
     63 pressure_test(async (t) => {
     64  await create_virtual_pressure_source('cpu');
     65  t.add_cleanup(async () => {
     66    await remove_virtual_pressure_source('cpu');
     67  });
     68 
     69  const observer = new PressureObserver(() => {
     70    assert_unreached('The observer callback should not be called');
     71  });
     72 
     73  await update_virtual_pressure_source('cpu', 'critical');
     74  const promise = observer.observe('cpu');
     75  observer.unobserve('cpu');
     76 
     77  return promise_rejects_dom(t, 'AbortError', promise);
     78 }, 'Removing observer before observe() resolves works');
     79 
     80 pressure_test(async (t) => {
     81  await create_virtual_pressure_source('cpu');
     82  t.add_cleanup(async () => {
     83    await remove_virtual_pressure_source('cpu');
     84  });
     85 
     86  const callbackPromises = [];
     87  const observePromises = [];
     88 
     89  for (let i = 0; i < 2; i++) {
     90    callbackPromises.push(new Promise(resolve => {
     91      const observer = new PressureObserver(resolve);
     92      t.add_cleanup(() => observer.disconnect());
     93      observePromises.push(observer.observe('cpu'));
     94    }));
     95  }
     96 
     97  await Promise.all(observePromises);
     98  await update_virtual_pressure_source('cpu', 'critical');
     99  return Promise.all(callbackPromises);
    100 }, 'Calling observe() multiple times works');
    101 
    102 pressure_test(async (t) => {
    103  await create_virtual_pressure_source('cpu');
    104  t.add_cleanup(async () => {
    105    await remove_virtual_pressure_source('cpu');
    106  });
    107 
    108  const observer1_promise = new Promise((resolve, reject) => {
    109    const observer = new PressureObserver(resolve);
    110    t.add_cleanup(() => observer.disconnect());
    111    observer.observe('cpu').catch(reject);
    112  });
    113  await update_virtual_pressure_source('cpu', 'critical');
    114  const observer1_changes = await observer1_promise;
    115  assert_equals(1, observer1_changes.length);
    116  assert_equals(observer1_changes[0].source, 'cpu');
    117  assert_equals(observer1_changes[0].state, 'critical');
    118 
    119  const observer2_changes = await new Promise((resolve, reject) => {
    120    const observer = new PressureObserver(resolve);
    121    t.add_cleanup(() => observer.disconnect());
    122    observer.observe('cpu').catch(reject);
    123  });
    124  assert_equals(1, observer2_changes.length);
    125  assert_equals(observer2_changes[0].source, 'cpu');
    126  assert_equals(observer2_changes[0].state, 'critical');
    127 }, 'Starting a new observer after an observer has started works');
    128 
    129 mark_as_done();