Implement TypedArray.slice().

test/mjsunit/harmony/typedarrays.js

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 51 matching lines @@
 
 function TestByteLengthNotWritable() {
   var ab = new ArrayBuffer(1024);
   assertSame(1024, ab.byteLength);
 
   assertThrows(function() { "use strict"; ab.byteLength = 42; }, TypeError);
 }
 
 TestByteLengthNotWritable();
 
-function TestSlice(expectedResultLen, initialLen, start, end) {
-  var ab = new ArrayBuffer(initialLen);
-  var a1 = new Uint8Array(ab);
-  for (var i = 0; i < a1.length; i++) {
-    a1[i] = 0xCA;
+function TestArrayBufferSlice() {
+  function TestSlice(expectedResultLen, initialLen, start, end) {
+    var ab = new ArrayBuffer(initialLen);
+    var a1 = new Uint8Array(ab);
+    for (var i = 0; i < a1.length; i++) {
+      a1[i] = 0xCA;
+    }
+    var slice = ab.slice(start, end);
+    assertSame(expectedResultLen, slice.byteLength);
+    var a2 = new Uint8Array(slice);
+    for (var i = 0; i < a2.length; i++) {
+      assertSame(0xCA, a2[i]);
+    }
   }
-  var slice = ab.slice(start, end);
-  assertSame(expectedResultLen, slice.byteLength);
-  var a2 = new Uint8Array(slice);
-  for (var i = 0; i < a2.length; i++) {
-    assertSame(0xCA, a2[i]);
-  }
-}
 
-function TestArrayBufferSlice() {
   var ab = new ArrayBuffer(1024);
   var ab1 = ab.slice(512, 1024);
   assertSame(512, ab1.byteLength);
 
   TestSlice(512, 1024, 512, 1024);
   TestSlice(512, 1024, 512);
 
   TestSlice(0, 0, 1, 20);
   TestSlice(100, 100, 0, 100);
   TestSlice(100, 100, 0, 1000);
@@ skipping 15 matching lines @@
   TestSlice(10, 100, 0.96, 10.01);
   TestSlice(10, 100, 0.01, 10.01);
   TestSlice(10, 100, 0.01, 10.96);
 
   TestSlice(10, 100, 90);
   TestSlice(10, 100, -10);
 }
 
 TestArrayBufferSlice();
 
+function TestTypedArraySlice() {
+  function TestSlice(expectedResultLen, initialLen, start, end) {
+    var a1 = new Uint32Array(initialLen);

[arv (Not doing code reviews), 2015/05/01 14:09:31]

Maybe pass the constructor to this function so that we can test more than
Uint32Array?

+    for (var i = 0; i < a1.length; i++) {
+      a1[i] = 0x12345678;
+    }
+    var slice = a1.slice(start, end);
+    assertSame(expectedResultLen, slice.length);
+    var a2 = new Uint32Array(slice);
+    for (var i = 0; i < a2.length; i++) {
+      assertSame(0x12345678, a2[i]);
+    }
+  }
+
+  var ab = new Uint32Array(1024);
+  var ab1 = ab.slice(512, 1024);
+  assertSame(512, ab1.length);
+
+  TestSlice(512, 1024, 512, 1024);
+  TestSlice(512, 1024, 512);
+
+  TestSlice(0, 0, 1, 20);
+  TestSlice(100, 100, 0, 100);
+  TestSlice(100, 100, 0, 1000);
+
+  TestSlice(0, 100, 5, 1);
+
+  TestSlice(1, 100, -11, -10);
+  TestSlice(9, 100, -10, 99);
+  TestSlice(0, 100, -10, 80);
+  TestSlice(10, 100, 80, -10);
+
+  TestSlice(10, 100, 90, "100");
+  TestSlice(10, 100, "90", "100");
+
+  TestSlice(0,  100, 90, "abc");
+  TestSlice(10, 100, "abc", 10);
+
+  TestSlice(10, 100, 0.96, 10.96);
+  TestSlice(10, 100, 0.96, 10.01);
+  TestSlice(10, 100, 0.01, 10.01);
+  TestSlice(10, 100, 0.01, 10.96);
+
+  TestSlice(10, 100, 90);
+  TestSlice(10, 100, -10);
+}
+
+TestTypedArraySlice();
+
 // Typed arrays
 
 function TestTypedArray(constr, elementSize, typicalElement) {
   assertSame(elementSize, constr.BYTES_PER_ELEMENT);
 
   var ab = new ArrayBuffer(256*elementSize);
 
   var a0 = new constr(30);
   assertEquals("[object " + constr.name + "]",
       Object.prototype.toString.call(a0));
@@ skipping 580 matching lines @@
 TestArbitrary(new ArrayBuffer(256));
 for(i = 0; i < typedArrayConstructors.length; i++) {
   TestArbitrary(new typedArrayConstructors[i](10));
 }
 TestArbitrary(new DataView(new ArrayBuffer(256)));
 
 
 // Test direct constructor call
 assertThrows(function() { ArrayBuffer(); }, TypeError);
 assertThrows(function() { DataView(new ArrayBuffer()); }, TypeError);