Add BYTES_PER_ELEMENT property to constructors of typed arrays.

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 99 matching lines @@
   TestSlice(10, 100, 0.01, 10.96);
 
   TestSlice(10, 100, 90);
   TestSlice(10, 100, -10);
 }
 
 TestArrayBufferSlice();
 
 // Typed arrays
 
-function TestTypedArray(proto, elementSize, typicalElement) {
+function TestTypedArray(constr, elementSize, typicalElement) {
+  assertSame(elementSize, constr.BYTES_PER_ELEMENT);
+
   var ab = new ArrayBuffer(256*elementSize);
 
-  var a0 = new proto(30);
+  var a0 = new constr(30);
   assertSame(elementSize, a0.BYTES_PER_ELEMENT);
   assertSame(30, a0.length);
   assertSame(30*elementSize, a0.byteLength);
   assertSame(0, a0.byteOffset);
   assertSame(30*elementSize, a0.buffer.byteLength);
 
-  var aLen0 = new proto(0);
+  var aLen0 = new constr(0);
   assertSame(elementSize, aLen0.BYTES_PER_ELEMENT);
   assertSame(0, aLen0.length);
   assertSame(0, aLen0.byteLength);
   assertSame(0, aLen0.byteOffset);
   assertSame(0, aLen0.buffer.byteLength);
 
-  var aOverBufferLen0 = new proto(ab, 128*elementSize, 0);
+  var aOverBufferLen0 = new constr(ab, 128*elementSize, 0);
   assertSame(ab, aOverBufferLen0.buffer);
   assertSame(elementSize, aOverBufferLen0.BYTES_PER_ELEMENT);
   assertSame(0, aOverBufferLen0.length);
   assertSame(0, aOverBufferLen0.byteLength);
   assertSame(128*elementSize, aOverBufferLen0.byteOffset);
 
-  var a1 = new proto(ab, 128*elementSize, 128);
+  var a1 = new constr(ab, 128*elementSize, 128);
   assertSame(ab, a1.buffer);
   assertSame(elementSize, a1.BYTES_PER_ELEMENT);
   assertSame(128, a1.length);
   assertSame(128*elementSize, a1.byteLength);
   assertSame(128*elementSize, a1.byteOffset);
 
 
-  var a2 = new proto(ab, 64*elementSize, 128);
+  var a2 = new constr(ab, 64*elementSize, 128);
   assertSame(ab, a2.buffer);
   assertSame(elementSize, a2.BYTES_PER_ELEMENT);
   assertSame(128, a2.length);
   assertSame(128*elementSize, a2.byteLength);
   assertSame(64*elementSize, a2.byteOffset);
 
-  var a3 = new proto(ab, 192*elementSize);
+  var a3 = new constr(ab, 192*elementSize);
   assertSame(ab, a3.buffer);
   assertSame(64, a3.length);
   assertSame(64*elementSize, a3.byteLength);
   assertSame(192*elementSize, a3.byteOffset);
 
-  var a4 = new proto(ab);
+  var a4 = new constr(ab);
   assertSame(ab, a4.buffer);
   assertSame(256, a4.length);
   assertSame(256*elementSize, a4.byteLength);
   assertSame(0, a4.byteOffset);
 
 
   var i;
   for (i = 0; i < 128; i++) {
     a1[i] = typicalElement;
   }
@@ skipping 15 matching lines @@
   }
 
   for (i = 0; i < 128; i++) {
     assertSame(0, a4[i]);
   }
 
   for (i = 128; i < 256; i++) {
     assertSame(typicalElement, a4[i]);
   }
 
-  var aAtTheEnd = new proto(ab, 256*elementSize);
+  var aAtTheEnd = new constr(ab, 256*elementSize);
   assertSame(elementSize, aAtTheEnd.BYTES_PER_ELEMENT);
   assertSame(0, aAtTheEnd.length);
   assertSame(0, aAtTheEnd.byteLength);
   assertSame(256*elementSize, aAtTheEnd.byteOffset);
 
-  assertThrows(function () { new proto(ab, 257*elementSize); }, RangeError);
+  assertThrows(function () { new constr(ab, 257*elementSize); }, RangeError);
   assertThrows(
-      function () { new proto(ab, 128*elementSize, 192); },
+      function () { new constr(ab, 128*elementSize, 192); },
       RangeError);
 
   if (elementSize !== 1) {
-    assertThrows(function() { new proto(ab, 128*elementSize - 1, 10); },
+    assertThrows(function() { new constr(ab, 128*elementSize - 1, 10); },
                  RangeError);
     var unalignedArrayBuffer = new ArrayBuffer(10*elementSize + 1);
-    var goodArray = new proto(unalignedArrayBuffer, 0, 10);
+    var goodArray = new constr(unalignedArrayBuffer, 0, 10);
     assertSame(10, goodArray.length);
     assertSame(10*elementSize, goodArray.byteLength);
-    assertThrows(function() { new proto(unalignedArrayBuffer)}, RangeError);
-    assertThrows(function() { new proto(unalignedArrayBuffer, 5*elementSize)},
+    assertThrows(function() { new constr(unalignedArrayBuffer)}, RangeError);
+    assertThrows(function() { new constr(unalignedArrayBuffer, 5*elementSize)},
                  RangeError);
   }
 
-  var aFromString = new proto("30");
+  var aFromString = new constr("30");
   assertSame(elementSize, aFromString.BYTES_PER_ELEMENT);
   assertSame(30, aFromString.length);
   assertSame(30*elementSize, aFromString.byteLength);
   assertSame(0, aFromString.byteOffset);
   assertSame(30*elementSize, aFromString.buffer.byteLength);
 
   var jsArray = [];
   for (i = 0; i < 30; i++) {
     jsArray.push(typicalElement);
   }
-  var aFromArray = new proto(jsArray);
+  var aFromArray = new constr(jsArray);
   assertSame(elementSize, aFromArray.BYTES_PER_ELEMENT);
   assertSame(30, aFromArray.length);
   assertSame(30*elementSize, aFromArray.byteLength);
   assertSame(0, aFromArray.byteOffset);
   assertSame(30*elementSize, aFromArray.buffer.byteLength);
   for (i = 0; i < 30; i++) {
     assertSame(typicalElement, aFromArray[i]);
   }
 
   var abLen0 = new ArrayBuffer(0);
-  var aOverAbLen0 = new proto(abLen0);
+  var aOverAbLen0 = new constr(abLen0);
   assertSame(abLen0, aOverAbLen0.buffer);
   assertSame(elementSize, aOverAbLen0.BYTES_PER_ELEMENT);
   assertSame(0, aOverAbLen0.length);
   assertSame(0, aOverAbLen0.byteLength);
   assertSame(0, aOverAbLen0.byteOffset);
 
-  var aNoParam = new proto();
+  var aNoParam = new constr();
   assertSame(elementSize, aNoParam.BYTES_PER_ELEMENT);
   assertSame(0, aNoParam.length);
   assertSame(0, aNoParam.byteLength);
   assertSame(0, aNoParam.byteOffset);
 }
 
 TestTypedArray(Uint8Array, 1, 0xFF);
 TestTypedArray(Int8Array, 1, -0x7F);
 TestTypedArray(Uint16Array, 2, 0xFFFF);
 TestTypedArray(Int16Array, 2, -0x7FFF);
@@ skipping 307 matching lines @@
 TestArbitrary(new ArrayBuffer(256));
 for(i = 0; i < typedArrayConstructors.lenght; i++) {
   TestArbitary(new typedArrayConstructors[i](10));
 }
 TestArbitrary(new DataView(new ArrayBuffer(256)));
 
 
 // Test direct constructor call
 assertThrows(function() { ArrayBuffer(); }, TypeError);
 assertThrows(function() { DataView(new ArrayBuffer()); }, TypeError);