tor-browser

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

growable-shared-array-buffers.js (4002B)

      1 const scopes = [
      2  "SameProcess",
      3 ];
      4 
      5 const g = newGlobal({enableCoopAndCoep: true});
      6 
      7 const options = {
      8  SharedArrayBuffer: "allow",
      9 };
     10 
     11 function testInt32Array(scope) {
     12  var length = 4;
     13  var byteLength = length * Int32Array.BYTES_PER_ELEMENT;
     14  var maxByteLength = 2 * byteLength;
     15 
     16  var ab = new SharedArrayBuffer(byteLength, {maxByteLength});
     17  assertEq(ab.growable, true);
     18  assertEq(ab.byteLength, byteLength);
     19  assertEq(ab.maxByteLength, maxByteLength);
     20 
     21  var ta1 = new Int32Array(ab);
     22  assertEq(ta1.byteLength, byteLength);
     23  ta1.set([1, 87654321, -123]);
     24  assertEq(ta1.toString(), "1,87654321,-123,0");
     25 
     26  var clonebuf = g.serialize(ta1, undefined, {scope, ...options});
     27  var ta2 = g.deserialize(clonebuf, {...options});
     28  assertEq(ta2 instanceof g.Int32Array, true);
     29  assertEq(ta2.byteLength, byteLength);
     30  assertEq(ta2.toString(), "1,87654321,-123,0");
     31  assertEq(ta2.buffer.growable, true);
     32  assertEq(ta2.buffer.byteLength, byteLength);
     33  assertEq(ta2.buffer.maxByteLength, maxByteLength);
     34 
     35  ta2.buffer.grow(maxByteLength);
     36  assertEq(ta2.byteLength, maxByteLength);
     37 }
     38 scopes.forEach(testInt32Array);
     39 
     40 function testFloat64Array(scope) {
     41  var length = 4;
     42  var byteLength = length * Float64Array.BYTES_PER_ELEMENT;
     43  var maxByteLength = 2 * byteLength;
     44 
     45  var ab = new SharedArrayBuffer(byteLength, {maxByteLength});
     46  assertEq(ab.growable, true);
     47  assertEq(ab.byteLength, byteLength);
     48  assertEq(ab.maxByteLength, maxByteLength);
     49 
     50  var ta1 = new Float64Array(ab);
     51  assertEq(ta1.byteLength, byteLength);
     52  ta1.set([NaN, 3.14, 0, 0]);
     53  assertEq(ta1.toString(), "NaN,3.14,0,0");
     54 
     55  var clonebuf = g.serialize(ta1, undefined, {scope, ...options});
     56  var ta2 = g.deserialize(clonebuf, {...options});
     57  assertEq(ta2 instanceof g.Float64Array, true);
     58  assertEq(ta2.byteLength, byteLength);
     59  assertEq(ta2.toString(), "NaN,3.14,0,0");
     60  assertEq(ta2.buffer.growable, true);
     61  assertEq(ta2.buffer.byteLength, byteLength);
     62  assertEq(ta2.buffer.maxByteLength, maxByteLength);
     63 
     64  ta2.buffer.grow(maxByteLength);
     65  assertEq(ta2.byteLength, maxByteLength);
     66 }
     67 scopes.forEach(testFloat64Array);
     68 
     69 function testDataView(scope) {
     70  var length = 4;
     71  var byteLength = length * Uint8Array.BYTES_PER_ELEMENT;
     72  var maxByteLength = 2 * byteLength;
     73 
     74  var ab = new SharedArrayBuffer(byteLength, {maxByteLength});
     75  assertEq(ab.growable, true);
     76  assertEq(ab.byteLength, byteLength);
     77  assertEq(ab.maxByteLength, maxByteLength);
     78 
     79  var ta = new Uint8Array(ab);
     80  ta.set([5, 0, 255]);
     81  assertEq(ta.toString(), "5,0,255,0");
     82  var dv1 = new DataView(ab);
     83  assertEq(dv1.byteLength, byteLength);
     84 
     85  var clonebuf = g.serialize(dv1, undefined, {scope, ...options});
     86  var dv2 = g.deserialize(clonebuf, {...options});
     87  assertEq(dv2 instanceof g.DataView, true);
     88  assertEq(dv2.byteLength, byteLength);
     89  assertEq(new Uint8Array(dv2.buffer).toString(), "5,0,255,0");
     90  assertEq(dv2.buffer.growable, true);
     91  assertEq(dv2.buffer.byteLength, byteLength);
     92  assertEq(dv2.buffer.maxByteLength, maxByteLength);
     93 
     94  dv2.buffer.grow(maxByteLength);
     95  assertEq(dv2.byteLength, maxByteLength);
     96 }
     97 scopes.forEach(testDataView);
     98 
     99 function testArrayBuffer(scope) {
    100  var length = 4;
    101  var byteLength = length * Uint8Array.BYTES_PER_ELEMENT;
    102  var maxByteLength = 2 * byteLength;
    103 
    104  var ab = new SharedArrayBuffer(byteLength, {maxByteLength});
    105  assertEq(ab.growable, true);
    106  assertEq(ab.byteLength, byteLength);
    107  assertEq(ab.maxByteLength, maxByteLength);
    108 
    109  var ta = new Uint8Array(ab);
    110  ta.set([33, 44, 55, 66]);
    111  assertEq(ta.toString(), "33,44,55,66");
    112 
    113  var clonebuf = g.serialize(ab, undefined, {scope, ...options});
    114  var ab2 = g.deserialize(clonebuf, {...options});
    115  assertEq(ab2 instanceof g.SharedArrayBuffer, true);
    116  assertEq(new Uint8Array(ab2).toString(), "33,44,55,66");
    117  assertEq(ab2.growable, true);
    118  assertEq(ab2.byteLength, byteLength);
    119  assertEq(ab2.maxByteLength, maxByteLength);
    120 
    121  ab2.grow(maxByteLength);
    122  assertEq(ab2.byteLength, maxByteLength);
    123 }
    124 scopes.forEach(testArrayBuffer);