tor-browser

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

microtask-smoke-test.js (3412B)

      1 // |jit-test| --setpref=use_js_microtask_queue=true;
      2 
      3 // Promise microtask queue smoke tests
      4 // Test basic promise resolution and microtask ordering
      5 
      6 // Test 1: Basic promise resolution
      7 let resolved = false;
      8 Promise.resolve(42).then(value => {
      9  assertEq(value, 42);
     10  resolved = true;
     11 });
     12 assertEq(resolved, false); // Should not be resolved synchronously
     13 drainJobQueue();
     14 assertEq(resolved, true); // Should be resolved after draining
     15 
     16 // Test 2: Promise rejection
     17 let rejected = false;
     18 let rejectionValue = null;
     19 Promise.reject("error").catch(err => {
     20  rejectionValue = err;
     21  rejected = true;
     22 });
     23 drainJobQueue();
     24 assertEq(rejected, true);
     25 assertEq(rejectionValue, "error");
     26 
     27 // Test 3: Chained promises
     28 let chainResult = [];
     29 Promise.resolve(1)
     30  .then(x => {
     31    chainResult.push(x);
     32    return x + 1;
     33  })
     34  .then(x => {
     35    chainResult.push(x);
     36    return x * 2;
     37  })
     38  .then(x => {
     39    chainResult.push(x);
     40  });
     41 drainJobQueue();
     42 assertEq(chainResult.length, 3);
     43 assertEq(chainResult[0], 1);
     44 assertEq(chainResult[1], 2);
     45 assertEq(chainResult[2], 4);
     46 
     47 // Test 4: Multiple independent promises
     48 let results = [];
     49 Promise.resolve("A").then(x => results.push(x));
     50 Promise.resolve("B").then(x => results.push(x));
     51 Promise.resolve("C").then(x => results.push(x));
     52 drainJobQueue();
     53 assertEq(results.length, 3);
     54 assertEq(results.includes("A"), true);
     55 assertEq(results.includes("B"), true);
     56 assertEq(results.includes("C"), true);
     57 
     58 // Test 5: Promise.all
     59 let allResolved = false;
     60 let allResults = null;
     61 Promise.all([
     62  Promise.resolve(10),
     63  Promise.resolve(20),
     64  Promise.resolve(30)
     65 ]).then(values => {
     66  allResults = values;
     67  allResolved = true;
     68 });
     69 drainJobQueue();
     70 assertEq(allResolved, true);
     71 assertEq(allResults.length, 3);
     72 assertEq(allResults[0], 10);
     73 assertEq(allResults[1], 20);
     74 assertEq(allResults[2], 30);
     75 
     76 // Test 6: Promise.race
     77 let raceWinner = null;
     78 Promise.race([
     79  Promise.resolve("first"),
     80  Promise.resolve("second")
     81 ]).then(winner => {
     82  raceWinner = winner;
     83 });
     84 drainJobQueue();
     85 assertEq(raceWinner, "first");
     86 
     87 // Test 7: Mixed sync/async execution order
     88 let executionOrder = [];
     89 executionOrder.push("sync1");
     90 Promise.resolve().then(() => executionOrder.push("async1"));
     91 executionOrder.push("sync2");
     92 Promise.resolve().then(() => executionOrder.push("async2"));
     93 executionOrder.push("sync3");
     94 drainJobQueue();
     95 assertEq(executionOrder[0], "sync1");
     96 assertEq(executionOrder[1], "sync2");
     97 assertEq(executionOrder[2], "sync3");
     98 assertEq(executionOrder[3], "async1");
     99 assertEq(executionOrder[4], "async2");
    100 
    101 // Test 8: Nested promise creation
    102 let nestedResults = [];
    103 Promise.resolve().then(() => {
    104  nestedResults.push("outer");
    105  Promise.resolve().then(() => {
    106    nestedResults.push("inner");
    107  });
    108 });
    109 drainJobQueue();
    110 assertEq(nestedResults.length, 2);
    111 assertEq(nestedResults[0], "outer");
    112 assertEq(nestedResults[1], "inner");
    113 
    114 // Test 9: Error handling in chains
    115 let errorCaught = false;
    116 let errorMessage = null;
    117 Promise.resolve()
    118  .then(() => {
    119    throw new Error("test error");
    120  })
    121  .catch(e => {
    122    errorCaught = true;
    123    errorMessage = e.message;
    124  });
    125 drainJobQueue();
    126 assertEq(errorCaught, true);
    127 assertEq(errorMessage, "test error");
    128 
    129 // Test 10: Promise constructor execution
    130 let constructorExecuted = false;
    131 let constructorResolve = null;
    132 new Promise((resolve, reject) => {
    133  constructorExecuted = true;
    134  constructorResolve = resolve;
    135 });
    136 assertEq(constructorExecuted, true);