tor-browser

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

map-has-bigint.js (4208B)

      1 // Similar test as "cacheir/map-has-bigint.js", except that we now perform
      2 // duplicate lookups to ensure GVN works properly.
      3 
      4 // Return a new map, possibly filling some dummy entries to enforce creating
      5 // multiple hash buckets.
      6 function createMap(values, n) {
      7  var xs = [...values];
      8  for (var i = 0; i < n; ++i) {
      9    xs.push({});
     10  }
     11  return new Map(xs.map((x, i) => [x, i]));
     12 }
     13 
     14 function runTest(fn) {
     15  fn(0);
     16  fn(100);
     17 }
     18 
     19 function testInlineDigitsSameSign_same_map(n) {
     20  var xs = [1n, 2n];
     21  var ys = [3n, 4n];
     22  var zs = [...xs, ...ys];
     23  var map = createMap(xs, n);
     24 
     25  var N = 100;
     26  var c = 0;
     27  for (var i = 0; i < N; ++i) {
     28    var z = zs[i & 3];
     29    if (map.has(z)) c++;
     30    if (map.has(z)) c++;
     31  }
     32  assertEq(c, N);
     33 }
     34 runTest(testInlineDigitsSameSign_same_map);
     35 
     36 function testInlineDigitsDifferentSign_same_map(n) {
     37  var xs = [-1n, 2n];
     38  var ys = [1n, -2n];
     39  var zs = [...xs, ...ys];
     40  var map = createMap(xs, n);
     41 
     42  var N = 100;
     43  var c = 0;
     44  for (var i = 0; i < N; ++i) {
     45    var z = zs[i & 3];
     46    if (map.has(z)) c++;
     47    if (map.has(z)) c++;
     48  }
     49  assertEq(c, N);
     50 }
     51 runTest(testInlineDigitsDifferentSign_same_map);
     52 
     53 function testHeapDigitsSameSign_same_map(n) {
     54  // Definitely uses heap digits.
     55  var heap = 2n ** 1000n;
     56 
     57  var xs = [heap + 1n, heap + 2n];
     58  var ys = [heap + 3n, heap + 4n];
     59  var zs = [...xs, ...ys];
     60  var map = createMap(xs, n);
     61 
     62  var N = 100;
     63  var c = 0;
     64  for (var i = 0; i < N; ++i) {
     65    var z = zs[i & 3];
     66    if (map.has(z)) c++;
     67    if (map.has(z)) c++;
     68  }
     69  assertEq(c, N);
     70 }
     71 runTest(testHeapDigitsSameSign_same_map);
     72 
     73 function testHeapDigitsDifferentSign_same_map(n) {
     74  // Definitely uses heap digits.
     75  var heap = 2n ** 1000n;
     76 
     77  var xs = [-(heap + 1n), heap + 2n];
     78  var ys = [heap + 1n, -(heap + 2n)];
     79  var zs = [...xs, ...ys];
     80  var map = createMap(xs, n);
     81 
     82  var N = 100;
     83  var c = 0;
     84  for (var i = 0; i < N; ++i) {
     85    var z = zs[i & 3];
     86    if (map.has(z)) c++;
     87    if (map.has(z)) c++;
     88  }
     89  assertEq(c, N);
     90 }
     91 runTest(testHeapDigitsDifferentSign_same_map);
     92 
     93 // Duplicate the above tests, but this time use a different map.
     94 
     95 function testInlineDigitsSameSign_different_map(n) {
     96  var xs = [1n, 2n];
     97  var ys = [3n, 4n];
     98  var zs = [...xs, ...ys];
     99  var map1 = createMap(xs, n);
    100  var map2 = createMap(xs, n);
    101 
    102  var N = 100;
    103  var c = 0;
    104  for (var i = 0; i < N; ++i) {
    105    var z = zs[i & 3];
    106    if (map1.has(z)) c++;
    107    if (map2.has(z)) c++;
    108  }
    109  assertEq(c, N);
    110 }
    111 runTest(testInlineDigitsSameSign_different_map);
    112 
    113 function testInlineDigitsDifferentSign_different_map(n) {
    114  var xs = [-1n, 2n];
    115  var ys = [1n, -2n];
    116  var zs = [...xs, ...ys];
    117  var map1 = createMap(xs, n);
    118  var map2 = createMap(xs, n);
    119 
    120  var N = 100;
    121  var c = 0;
    122  for (var i = 0; i < N; ++i) {
    123    var z = zs[i & 3];
    124    if (map1.has(z)) c++;
    125    if (map2.has(z)) c++;
    126  }
    127  assertEq(c, N);
    128 }
    129 runTest(testInlineDigitsDifferentSign_different_map);
    130 
    131 function testHeapDigitsSameSign_different_map(n) {
    132  // Definitely uses heap digits.
    133  var heap = 2n ** 1000n;
    134 
    135  var xs = [heap + 1n, heap + 2n];
    136  var ys = [heap + 3n, heap + 4n];
    137  var zs = [...xs, ...ys];
    138  var map1 = createMap(xs, n);
    139  var map2 = createMap(xs, n);
    140 
    141  var N = 100;
    142  var c = 0;
    143  for (var i = 0; i < N; ++i) {
    144    var z = zs[i & 3];
    145    if (map1.has(z)) c++;
    146    if (map2.has(z)) c++;
    147  }
    148  assertEq(c, N);
    149 }
    150 runTest(testHeapDigitsSameSign_different_map);
    151 
    152 function testHeapDigitsDifferentSign_different_map(n) {
    153  // Definitely uses heap digits.
    154  var heap = 2n ** 1000n;
    155 
    156  var xs = [-(heap + 1n), heap + 2n];
    157  var ys = [heap + 1n, -(heap + 2n)];
    158  var zs = [...xs, ...ys];
    159  var map1 = createMap(xs, n);
    160  var map2 = createMap(xs, n);
    161 
    162  var N = 100;
    163  var c = 0;
    164  for (var i = 0; i < N; ++i) {
    165    var z = zs[i & 3];
    166    if (map1.has(z)) c++;
    167    if (map2.has(z)) c++;
    168  }
    169  assertEq(c, N);
    170 }
    171 runTest(testHeapDigitsDifferentSign_different_map);
    172 
    173 // Test the alias information is correct.
    174 
    175 function test_alias(n) {
    176  var xs = [1n, 2n];
    177  var map = createMap([], n);
    178 
    179  var N = 100;
    180  var c = 0;
    181  for (var i = 0; i < N; ++i) {
    182    var x = xs[i & 1];
    183 
    184    map.set(x, x);
    185    if (map.has(x)) c++;
    186 
    187    map.delete(x);
    188    if (map.has(x)) c++;
    189  }
    190  assertEq(c, N);
    191 }
    192 runTest(test_alias);