tor-browser

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

disposal-during-non-local-jump-try.js (5679B)

      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 
      8  function testDisposeWithTryAndScopes() {
      9    try {
     10      using d = {
     11        [Symbol.dispose]() {
     12          disposed.push(1);
     13        }
     14      };
     15      {
     16        using d2 = {
     17          [Symbol.dispose]() {
     18            disposed.push(2);
     19          }
     20        };
     21        {
     22          let a = 0, b = () => a;
     23          {
     24            throw new Error("err");
     25          }
     26        }
     27      }
     28    } catch (e) {
     29      disposed.push(3);
     30    } finally {
     31      using d3 = {
     32        [Symbol.dispose]() {
     33          disposed.push(4);
     34        }
     35      };
     36      disposed.push(5);
     37    }
     38  }
     39  testDisposeWithTryAndScopes();
     40  assertArrayEq(disposed, [2, 1, 3, 5, 4]);
     41 }
     42 
     43 {
     44  const disposed = [];
     45 
     46  function testTryWithJumpsOutOfLoopFromTryWithBreak() {
     47    const w = {
     48      [Symbol.dispose]() {
     49        disposed.push(0);
     50      }
     51    }
     52    outer: for (let a of [1]) {
     53      for (using a of [w]) {
     54        try {
     55          using x = {
     56            [Symbol.dispose]() {
     57              disposed.push(1);
     58            }
     59          };
     60          break outer;
     61        } catch {
     62        } finally {
     63          using y = {
     64            [Symbol.dispose]() {
     65              disposed.push(2);
     66            }
     67          };
     68          disposed.push(3);
     69        }
     70      }
     71    }
     72  }
     73  testTryWithJumpsOutOfLoopFromTryWithBreak();
     74  assertArrayEq(disposed, [1, 3, 2, 0]);
     75 }
     76 
     77 {
     78  const disposed = [];
     79 
     80  function testTryWithJumpsOutOfLoopFromTryWithContinue() {
     81    const w = {
     82      [Symbol.dispose]() {
     83        disposed.push(0);
     84      }
     85    }
     86    outer: for (let a of [1]) {
     87      for (using a of [w]) {
     88        try {
     89          using x = {
     90            [Symbol.dispose]() {
     91              disposed.push(1);
     92            }
     93          };
     94          continue outer;
     95        } catch {
     96        } finally {
     97          using y = {
     98            [Symbol.dispose]() {
     99              disposed.push(2);
    100            }
    101          };
    102          disposed.push(3);
    103        }
    104      }
    105    }
    106  }
    107  testTryWithJumpsOutOfLoopFromTryWithContinue();
    108  assertArrayEq(disposed, [1, 3, 2, 0]);
    109 }
    110 
    111 {
    112  const disposed = [];
    113 
    114  function testTryWithJumpsOutOfLoopFromCatchWithBreak() {
    115    const w = {
    116      [Symbol.dispose]() {
    117        disposed.push(0);
    118      }
    119    }
    120    outer: for (let a of [1]) {
    121      for (using a of [w]) {
    122        try {
    123          using x = {
    124            [Symbol.dispose]() {
    125              disposed.push(1);
    126            }
    127          };
    128          throw new Error("err");
    129        } catch {
    130          using z = {
    131            [Symbol.dispose]() {
    132              disposed.push(4);
    133            }
    134          };
    135          break outer;
    136        } finally {
    137          using y = {
    138            [Symbol.dispose]() {
    139              disposed.push(2);
    140            }
    141          };
    142          disposed.push(3);
    143        }
    144      }
    145    }
    146  }
    147  testTryWithJumpsOutOfLoopFromCatchWithBreak();
    148  assertArrayEq(disposed, [1, 4, 3, 2, 0]);
    149 }
    150 
    151 {
    152  const disposed = [];
    153 
    154  function testTryWithJumpsOutOfLoopFromCatchWithContinue() {
    155    const w = {
    156      [Symbol.dispose]() {
    157        disposed.push(0);
    158      }
    159    }
    160    outer: for (let a of [1, 2]) {
    161      for (using a of [w]) {
    162        try {
    163          using x = {
    164            [Symbol.dispose]() {
    165              disposed.push(1);
    166            }
    167          };
    168          throw new Error("err");
    169        } catch {
    170          using z = {
    171            [Symbol.dispose]() {
    172              disposed.push(4);
    173            }
    174          };
    175          continue outer;
    176        }
    177      }
    178    }
    179  }
    180  testTryWithJumpsOutOfLoopFromCatchWithContinue();
    181  assertArrayEq(disposed, [1, 4, 0, 1, 4, 0]);
    182 }
    183 
    184 {
    185  const disposed = [];
    186 
    187  function testTryWithJumpsOutOfLoopFromFinallyWithBreak() {
    188    const w = {
    189      [Symbol.dispose]() {
    190        disposed.push(0);
    191      }
    192    }
    193    outer: for (let a of [1, 2]) {
    194      for (using a of [w]) {
    195        try {
    196          using x = {
    197            [Symbol.dispose]() {
    198              disposed.push(1);
    199            }
    200          };
    201        } finally {
    202          using z = {
    203            [Symbol.dispose]() {
    204              disposed.push(4);
    205            }
    206          };
    207          break outer;
    208        }
    209      }
    210    }
    211  }
    212  testTryWithJumpsOutOfLoopFromFinallyWithBreak();
    213  assertArrayEq(disposed, [1, 4, 0]);
    214 }
    215 
    216 {
    217  const disposed = [];
    218 
    219  function testTryWithJumpsOutOfLoopFromFinallyWithContinue() {
    220    const w = {
    221      [Symbol.dispose]() {
    222        disposed.push(0);
    223      }
    224    }
    225    outer: for (let a of [1, 2]) {
    226      for (using a of [w]) {
    227        try {
    228          using x = {
    229            [Symbol.dispose]() {
    230              disposed.push(1);
    231            }
    232          };
    233        } finally {
    234          using z = {
    235            [Symbol.dispose]() {
    236              disposed.push(4);
    237            }
    238          };
    239          continue outer;
    240        }
    241      }
    242    }
    243  }
    244  testTryWithJumpsOutOfLoopFromFinallyWithContinue();
    245  assertArrayEq(disposed, [1, 4, 0, 1, 4, 0]);
    246 }
    247 
    248 {
    249  const disposed = [];
    250 
    251  function testTryWithJumpsOutOfLoopExtraScope() {
    252    const w = {
    253      [Symbol.dispose]() {
    254        disposed.push(0);
    255      }
    256    }
    257    outer: for (let a of [1, 2]) {
    258      for (using a of [w]) {
    259        try {
    260          using x = {
    261            [Symbol.dispose]() {
    262              disposed.push(1);
    263            }
    264          };
    265        } finally {
    266          using z = {
    267            [Symbol.dispose]() {
    268              disposed.push(4);
    269            }
    270          };
    271          {
    272            let a = 0, b = () => a;
    273            break outer;
    274          }
    275        }
    276      }
    277    }
    278  }
    279  testTryWithJumpsOutOfLoopExtraScope();
    280  assertArrayEq(disposed, [1, 4, 0]);
    281 }