tor-browser

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

slice.js (3005B)

      1 // |jit-test| skip-if: !this.SharedArrayBuffer
      2 
      3 // SharedArrayBuffer.prototype.slice
      4 
      5 load(libdir + "asserts.js");
      6 
      7 let buf = new SharedArrayBuffer(1024);
      8 let bufAsI8 = new Int8Array(buf);
      9 for ( let i=0 ; i < buf.length ; i++ )
     10    bufAsI8[i] = i;
     11 
     12 let base = 10;
     13 let len = 10;
     14 
     15 let buf2 = buf.slice(base, base+len);
     16 
     17 // Smells right?
     18 assertEq(buf2 instanceof SharedArrayBuffer, true);
     19 assertEq(buf2.byteLength, len);
     20 
     21 // Data got copied correctly?
     22 let buf2AsI8 = new Int8Array(buf2);
     23 for ( let i=0 ; i < buf2AsI8.length ; i++ )
     24    assertEq(buf2AsI8[i], bufAsI8[base+i]);
     25 
     26 // Storage not shared?
     27 let correct = bufAsI8[base];
     28 bufAsI8[base]++;
     29 assertEq(buf2AsI8[0], correct);
     30 
     31 // Start beyond end
     32 let notail = buf.slice(buf.byteLength+1);
     33 assertEq(notail.byteLength, 0);
     34 
     35 // Negative start
     36 let tail = buf.slice(-5, buf.byteLength);
     37 assertEq(tail.byteLength, 5);
     38 let tailAsI8 = new Int8Array(tail);
     39 for ( let i=0 ; i < tailAsI8.length ; i++ )
     40    assertEq(tailAsI8[i], bufAsI8[buf.byteLength-5+i]);
     41 
     42 // Negative end
     43 let head = buf.slice(0, -5);
     44 assertEq(head.byteLength, buf.byteLength-5);
     45 let headAsI8 = new Int8Array(head);
     46 for ( let i=0 ; i < headAsI8.length ; i++ )
     47    assertEq(headAsI8[i], bufAsI8[i]);
     48 
     49 // Subtyping
     50 class MySharedArrayBuffer1 extends SharedArrayBuffer {
     51    constructor(n) { super(n) }
     52 }
     53 
     54 let myBuf = new MySharedArrayBuffer1(1024);
     55 
     56 let myBufAsI8 = new Int8Array(myBuf);
     57 for ( let i=0 ; i < myBuf.length ; i++ )
     58    myBufAsI8[i] = i;
     59 
     60 let myBufSlice = myBuf.slice(0, 20);
     61 
     62 assertEq(myBufSlice instanceof MySharedArrayBuffer1, true);
     63 
     64 assertEq(myBufSlice.byteLength, 20);
     65 
     66 let myBufSliceAsI8 = new Int8Array(myBufSlice);
     67 for ( let i=0 ; i < myBufSlice.length ; i++ )
     68    assertEq(myBufAsI8[i], myBufSliceAsI8[i]);
     69 
     70 // Error mode: the method requires an object
     71 assertThrowsInstanceOf(() => buf.slice.call(false, 0, 1), TypeError);
     72 
     73 // Error mode: the method is not generic.
     74 assertThrowsInstanceOf(() => buf.slice.call([1,2,3], 0, 1), TypeError);
     75 
     76 // Error mode (step 15): the buffer constructed on behalf of slice
     77 // is too short.
     78 
     79 class MySharedArrayBuffer2 extends SharedArrayBuffer {
     80    constructor(n) { super(n-1) }
     81 }
     82 
     83 let myBuf2 = new MySharedArrayBuffer2(10);
     84 
     85 assertThrowsInstanceOf(() => myBuf2.slice(0, 5), TypeError);
     86 
     87 // Error mode (step 13): the buffer constructed on behalf of slice
     88 // is not a SharedArrayBuffer.
     89 
     90 let subvert = false;
     91 
     92 class MySharedArrayBuffer3 extends SharedArrayBuffer {
     93    constructor(n) {
     94 super(n);
     95 if (subvert)
     96     return new Array(n);
     97    }
     98 }
     99 
    100 let myBuf3 = new MySharedArrayBuffer3(10);
    101 
    102 subvert = true;
    103 assertThrowsInstanceOf(() => myBuf3.slice(0, 5), TypeError);
    104 
    105 // Error mode (step 14): the buffer constructed on behalf of slice
    106 // is the same as the input buffer.
    107 
    108 let sneaky = null;
    109 
    110 class MySharedArrayBuffer4 extends SharedArrayBuffer {
    111    constructor(n) {
    112 super(n);
    113 if (sneaky)
    114     return sneaky;
    115    }
    116 }
    117 
    118 let myBuf4 = new MySharedArrayBuffer4(10);
    119 
    120 sneaky = myBuf4;
    121 assertThrowsInstanceOf(() => myBuf4.slice(0, 5), TypeError);