tor-browser

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

await-using-with-try-catch-finally.js (3826B)

      1 // |jit-test| skip-if: !getBuildConfiguration("explicit-resource-management"); --enable-explicit-resource-management
      2 
      3 load(libdir + "asserts.js");
      4 
      5 {
      6  const disposed = [];
      7  let release;
      8  const p = new Promise((resolve) => {
      9    release = resolve;
     10  });
     11  async function testTryFinallyWithAwaitUsingWithAwaitsInTry() {
     12    try {
     13      await using x = {
     14        [Symbol.asyncDispose]() {
     15          disposed.push(1);
     16        }
     17      }
     18      await p;
     19      await using y = {
     20        [Symbol.asyncDispose]() {
     21          disposed.push(2);
     22        }
     23      }
     24    } finally {
     25      await using z = {
     26        [Symbol.asyncDispose]() {
     27          disposed.push(3);
     28        }
     29      }
     30    }
     31  }
     32  testTryFinallyWithAwaitUsingWithAwaitsInTry();
     33  release();
     34  drainJobQueue();
     35  assertArrayEq(disposed, [2, 1, 3]);
     36 }
     37 
     38 {
     39  const disposed = [];
     40  let release;
     41  const p = new Promise((resolve) => {
     42    release = resolve;
     43  });
     44  async function testTryFinallyWithAwaitUsingWithAwaitsInFinally() {
     45    try {
     46      await using x = {
     47        [Symbol.asyncDispose]() {
     48          disposed.push(1);
     49        }
     50      };
     51      await using y = {
     52        [Symbol.asyncDispose]() {
     53          disposed.push(2);
     54        }
     55      };
     56    } finally {
     57      await using z = {
     58        [Symbol.asyncDispose]() {
     59          disposed.push(3);
     60        }
     61      };
     62      await p;
     63      await using w = {
     64        [Symbol.asyncDispose]() {
     65          disposed.push(4);
     66        }
     67      }
     68    }
     69  }
     70  testTryFinallyWithAwaitUsingWithAwaitsInFinally();
     71  release();
     72  drainJobQueue();
     73  assertArrayEq(disposed, [2, 1, 4, 3]);
     74 }
     75 
     76 {
     77  const disposed = [];
     78  let val;
     79  async function testTryFinallyWithAwaitUsingAndReturnsInTry() {
     80    try {
     81      await using x = {
     82        [Symbol.asyncDispose]() {
     83          disposed.push(1);
     84        }
     85      }
     86      await using y = {
     87        [Symbol.asyncDispose]() {
     88          disposed.push(2);
     89        }
     90      }
     91      return 42;
     92    } finally {
     93      await using y = {
     94        [Symbol.asyncDispose]() {
     95          disposed.push(3);
     96        }
     97      }
     98    }
     99  }
    100  testTryFinallyWithAwaitUsingAndReturnsInTry().then((v) => {
    101    val = v;
    102  });
    103  drainJobQueue();
    104  assertEq(val, 42);
    105  assertArrayEq(disposed, [2, 1, 3]);
    106 }
    107 
    108 {
    109  const disposed = [];
    110  let val;
    111  async function testTryCatchFinallyWithAwaitUsingAndReturnsInCatch() {
    112    try {
    113      await using x = {
    114        [Symbol.asyncDispose]() {
    115          disposed.push(1);
    116        }
    117      }
    118      await using y = {
    119        [Symbol.asyncDispose]() {
    120          disposed.push(2);
    121        }
    122      }
    123      throw new Error("test");
    124    } catch (e) {
    125      await using z = {
    126        [Symbol.asyncDispose]() {
    127          disposed.push(3);
    128        }
    129      }
    130      return 42;
    131    } finally {
    132      await using y = {
    133        [Symbol.asyncDispose]() {
    134          disposed.push(4);
    135        }
    136      }
    137    }
    138  }
    139  testTryCatchFinallyWithAwaitUsingAndReturnsInCatch().then((v) => {
    140    val = v;
    141  });
    142  drainJobQueue();
    143  assertEq(val, 42);
    144  assertArrayEq(disposed, [2, 1, 3, 4]);
    145 }
    146 
    147 {
    148  const disposed = [];
    149  let val;
    150  async function testTryCatchFinallyWithAwaitUsingAndReturnsInFinally() {
    151    try {
    152      await using x = {
    153        [Symbol.asyncDispose]() {
    154          disposed.push(1);
    155        }
    156      }
    157      await using y = {
    158        [Symbol.asyncDispose]() {
    159          disposed.push(2);
    160        }
    161      }
    162      throw new Error("test");
    163    } catch (e) {
    164      await using z = {
    165        [Symbol.asyncDispose]() {
    166          disposed.push(3);
    167        }
    168      }
    169      return 42;
    170    } finally {
    171      await using y = {
    172        [Symbol.asyncDispose]() {
    173          disposed.push(4);
    174        }
    175      }
    176      return 43;
    177    }
    178  }
    179  testTryCatchFinallyWithAwaitUsingAndReturnsInFinally().then((v) => {
    180    val = v;
    181  });
    182  drainJobQueue();
    183  assertEq(val, 43);
    184  assertArrayEq(disposed, [2, 1, 3, 4]);
    185 }