tor-browser

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

disposable-stack-use-dispose.js (2854B)

      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  const stack = new DisposableStack();
      8  const obj = {
      9    [Symbol.dispose]() {
     10      disposed.push(1);
     11    },
     12  };
     13  stack.use(obj);
     14  assertEq(stack.disposed, false);
     15  assertEq(stack.dispose(), undefined);
     16  assertEq(stack.disposed, true);
     17  assertArrayEq(disposed, [1]);
     18  assertThrowsInstanceOf(() => stack.use(obj), ReferenceError);
     19 }
     20 
     21 {
     22  const disposed = [];
     23  const stack = new DisposableStack();
     24  for (let i = 0; i < 5; i++) {
     25    stack.use({
     26      [Symbol.dispose]() {
     27        disposed.push(i);
     28      },
     29    });
     30  }
     31  assertEq(stack.disposed, false);
     32  stack.dispose();
     33  assertEq(stack.disposed, true);
     34  assertArrayEq(disposed, [4, 3, 2, 1, 0]);
     35  stack.dispose();
     36  assertArrayEq(disposed, [4, 3, 2, 1, 0]);
     37 }
     38 
     39 {
     40  const disposed = [];
     41  const stack = new DisposableStack();
     42  for (let i = 0; i < 5; i++) {
     43    stack.use({
     44      [Symbol.dispose]() {
     45        disposed.push(i);
     46      },
     47    });
     48  }
     49  assertEq(stack.disposed, false);
     50  {
     51    using stk = stack;
     52  }
     53  assertEq(stack.disposed, true);
     54  assertArrayEq(disposed, [4, 3, 2, 1, 0]);
     55  {
     56    using stk2 = stack;
     57  }
     58  assertArrayEq(disposed, [4, 3, 2, 1, 0]);
     59 }
     60 
     61 {
     62  const disposed = [];
     63  const stack = new DisposableStack();
     64  for (let i = 0; i < 5; i++) {
     65    stack.use({
     66      [Symbol.dispose]() {
     67        disposed.push(i);
     68      },
     69    });
     70  }
     71  assertEq(stack.disposed, false);
     72  {
     73    using z = stack;
     74    z.use({
     75      [Symbol.dispose]() {
     76        disposed.push(5);
     77      },
     78    });
     79    assertEq(stack.disposed, false);
     80  }
     81  assertEq(stack.disposed, true);
     82  assertArrayEq(disposed, [5, 4, 3, 2, 1, 0]);
     83 }
     84 
     85 {
     86  const disposed = [];
     87  const stack = new DisposableStack();
     88  stack.use(undefined);
     89  stack.use(null);
     90  stack.use({
     91    [Symbol.dispose]() {
     92      disposed.push(1);
     93    }
     94  });
     95  stack.dispose();
     96  assertArrayEq(disposed, [1]);
     97 }
     98 
     99 {
    100  const disposed = [];
    101  const stack = new DisposableStack();
    102  stack.use({
    103    [Symbol.dispose]() {
    104      disposed.push(1);
    105      stack.use({
    106        [Symbol.dispose]() {
    107          disposed.push(2);
    108        },
    109      });
    110    }
    111  });
    112  assertThrowsInstanceOf(() => stack.dispose(), ReferenceError);
    113 }
    114 
    115 {
    116  assertThrowsInstanceOf(() => {
    117    const stack = new DisposableStack();
    118    stack.use(1);
    119  }, TypeError);
    120 }
    121 
    122 {
    123  assertThrowsInstanceOf(() => {
    124    const stack = new DisposableStack();
    125    stack.use({
    126      [Symbol.dispose]: undefined
    127    });
    128  }, TypeError);
    129 
    130  assertThrowsInstanceOf(() => {
    131    const stack = new DisposableStack();
    132    stack.use({
    133      [Symbol.dispose]: null
    134    });
    135  }, TypeError);
    136 
    137  assertThrowsInstanceOf(() => {
    138    const stack = new DisposableStack();
    139    stack.use({
    140      [Symbol.dispose]: 1
    141    });
    142  }, TypeError);
    143 }