Issue 507 - Implement lightweight array.slice() method

test/tests/typedObjects.js

 /*
  * This file is part of Adblock Plus <https://adblockplus.org/>,
  * Copyright (C) 2006-2015 Eyeo GmbH
  *
  * Adblock Plus is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 3 as
  * published by the Free Software Foundation.
  *
  * Adblock Plus is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with Adblock Plus.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 (function()
 {
+  "use strict";
   module("Typed objects");
 
   test("Math utilities", function()
   {
     let {nextPow2, ilog2} = require("typedObjects/utils");
 
     equal(nextPow2(0), 0, "nextPow2(0)");
     equal(nextPow2(1), 1, "nextPow2(1)");
     equal(nextPow2(2), 2, "nextPow2(2)");
     equal(nextPow2(3), 4, "nextPow2(3)");
@@ skipping 674 matching lines @@
     deepEqual(array.toJS(), [5, 2, 8], "Pushing three elements succeeded");
 
     equal(array.pop(), 8, "Popping returns element");
     equal(array.pop(), 2, "Popping returns element");
     deepEqual(array.toJS(), [5], "Popping two elements succeeded");
 
     equal(array.unshift(4), 2, "Unshifting returns new length");
     equal(array.unshift(0, 9), 4, "Unshifting returns new length");
     deepEqual(array.toJS(), [0, 9, 4, 5], "Unshifting two elements succeeded");
 
+    let sliced = array.slice(1, 3);
+    deepEqual(sliced.toJS(), [9, 4], "Slicing an array works");
+    sliced.release();
+    deepEqual(sliced.toJS(), [], "Releasing a sliced array works");
+    deepEqual(array.toJS(), [0, 9, 4, 5], "Releasing a sliced array does not release the parent");
+    array.release();
+    deepEqual(array.toJS(), [], "Releasing a previously sliced array works");
+
+    array = uint32Array();
+    array.push(0, 9, 4, 5);
+    sliced = array.slice();
+    array.release();
+    deepEqual(sliced.toJS(), [0, 9, 4, 5], "Releasing a parent does not release a sliced array");
+    sliced.release();
+    deepEqual(sliced.toJS(), [], "Releasing a parent and sliced array does release a sliced array");
+
+    array = uint32Array();
+    array.push(0, 9, 4, 5);
+    sliced = array.slice(3);
+    deepEqual(sliced.toJS(), [5], "Array slicing adjusts byteOffset correctly");
+    deepEqual(array.toJS(), [0, 9, 4, 5], "Slicing an array does not alter the original array");
+    sliced.release();
+
+    sliced = array.slice(0);
+    deepEqual(sliced.toJS(), [0, 9, 4, 5], "Slicing can be used as 'copy'");
+    sliced.release();
+
+    sliced = array.slice(-2);
+    deepEqual(sliced.toJS(), [4, 5], "Slicing supports negative start index");
+    sliced.release();
+
+    sliced = array.slice(-10);
+    deepEqual(sliced.toJS(), [0, 9, 4, 5], "Slicing supports excessive negative start index");
+    sliced.release();
+
+    sliced = array.slice(-3, -1);
+    deepEqual(sliced.toJS(), [9, 4], "Slicing supports negative start and end index");
+    sliced.release();
+
+    sliced = array.slice(-10, -100);
+    deepEqual(sliced.toJS(), [], "Slicing supports excessive negative start and end index");
+    sliced.release();
+
+    sliced = array.slice(1, -1);
+    deepEqual(sliced.toJS(), [9, 4], "Slicing supports negative end index");
+    sliced.release();
+
+    sliced = array.slice(1, 3);
+    deepEqual(sliced.toJS(), [9, 4], "Slicing supports positive end index");
+    array.set(1, 8);
+    deepEqual(sliced.toJS(), [8, 4], "Sliced arrays rely on shared data");
+    sliced.release();
+
+    sliced = array.slice(1, 300);
+    deepEqual(sliced.toJS(), [8, 4, 5], "Slicing supports excessive positive end index");
+    sliced.release();
+
+    sliced = array.slice(100, 300);
+    deepEqual(sliced.toJS(), [], "Slicing supports excessive positive start and end index");
+    sliced.release();
+
+    sliced = array.slice();
+    throws(() => array.length = 1, "Length of sliced array is read only");
+    throws(() => sliced.length = 1, "Length of sliced array result is read only");
+
+    equal(array._refCount, 2, "Slicing an array increases it's refcount");
+    equal(sliced._refCount, 1, "Sliced arrays have a seperate refcount");
+    sliced.release();
+    equal(array._refCount, 1, "Releasing a sliced array decreases parent's refcount");
+
+    array = uint32Array();
+    array.push(0, 9, 4, 5, 6, 7);
+    array.length = 4;
+    equal(array.length, 4, "Length of non-sliced array is writable");
+
     equal(array.shift(), 0, "Shifting returns element");
     equal(array.shift(), 9, "Shifting returns element");
     deepEqual(array.toJS(), [4, 5], "Shifting by two elements succeeded");
 
     array.splice(1, 0, 1, 7);
     deepEqual(array.toJS(), [4, 1, 7, 5], "Using splice to insert elements succeeded");
     array.splice(2, 1);
     deepEqual(array.toJS(), [4, 1, 5], "Using splice to remove an element succeeded");
     array.splice(0, 2, 9);
     deepEqual(array.toJS(), [9, 5], "Using splice to remove two elements and insert one succeeded");
@@ skipping 78 matching lines @@
     s11.release();
 
     let s12 = string(s8, 4);
     ok(s12, "String created as typed substring without length parameter");
     equal(s12.length, 10, "String length set correctly");
     equal(s12.toString(), "longstring", "JavaScript representation is correct");
     s12.release();
     s8.release();
   });
 })();