Add type checks to typed array property getters.

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 305 matching lines @@
 TestSubArray(Uint8ClampedArray, 0xFF);
 
 function TestTypedArrayOutOfRange(constructor, value, result) {
   var a = new constructor(1);
   a[0] = value;
   assertSame(result, a[0]);
 }
 
 TestTypedArrayOutOfRange(Uint8Array, 0x1FA, 0xFA);
 TestTypedArrayOutOfRange(Uint8Array, -1, 0xFF);
+
 TestTypedArrayOutOfRange(Int8Array, 0x1FA, 0x7A - 0x80);
 
 TestTypedArrayOutOfRange(Uint16Array, 0x1FFFA, 0xFFFA);
 TestTypedArrayOutOfRange(Uint16Array, -1, 0xFFFF);
 TestTypedArrayOutOfRange(Int16Array, 0x1FFFA, 0x7FFA - 0x8000);
 
 TestTypedArrayOutOfRange(Uint32Array, 0x1FFFFFFFA, 0xFFFFFFFA);
 TestTypedArrayOutOfRange(Uint32Array, -1, 0xFFFFFFFF);
 TestTypedArrayOutOfRange(Int32Array, 0x1FFFFFFFA, 0x7FFFFFFA - 0x80000000);
 
 TestTypedArrayOutOfRange(Uint8ClampedArray, 0x1FA, 0xFF);
 TestTypedArrayOutOfRange(Uint8ClampedArray, -1, 0);
 
+var typedArrayConstructors = [
+  Uint8Array,
+  Int8Array,
+  Uint16Array,
+  Int16Array,
+  Uint32Array,
+  Int32Array,
+  Uint8ClampedArray,
+  Float32Array,
+  Float64Array]
 function TestPropertyTypeChecks(constructor) {
-  function CheckThrows(name) {
+  var a = new constructor();
+  function CheckProperty(name) {
     var d = Object.getOwnPropertyDescriptor(constructor.prototype, name);
     var o = {}
     assertThrows(function() {d.get.call(o);}, TypeError);
+    d.get.call(a); // shouldn't throw
+    for (var i = 0 ; i < typedArrayConstructors.length; i++) {
+      d.get.call(new typedArrayConstructors[i](10));
+    }
   }
 
-  CheckThrows("buffer");
-  CheckThrows("byteOffset");
-  CheckThrows("byteLength");
-  CheckThrows("length");
+  CheckProperty("buffer");
+  CheckProperty("byteOffset");
+  CheckProperty("byteLength");
+  CheckProperty("length");
 }
 
-TestPropertyTypeChecks(Uint8Array);
-TestPropertyTypeChecks(Int8Array);
-TestPropertyTypeChecks(Uint16Array);
-TestPropertyTypeChecks(Int16Array);
-TestPropertyTypeChecks(Uint32Array);
-TestPropertyTypeChecks(Int32Array);
-TestPropertyTypeChecks(Uint8ClampedArray);
-TestPropertyTypeChecks(Float32Array);
-TestPropertyTypeChecks(Float64Array);
+for(i = 0; i < typedArrayConstructors.lenght; i++) {
+  TestPropertyTypeChecks(typedArrayConstructors[i]);
+}
+
 
 // General tests for properties
 
 // Test property attribute [[Enumerable]]
 function TestEnumerable(func, obj) {
   function props(x) {
     var array = [];
     for (var p in x) array.push(p);
     return array.sort();
   }
   assertArrayEquals([], props(func));
   assertArrayEquals([], props(func.prototype));
   if (obj)
     assertArrayEquals([], props(obj));
 }
 TestEnumerable(ArrayBuffer, new ArrayBuffer());
-TestEnumerable(Uint8Array);
-TestEnumerable(Int8Array);
-TestEnumerable(Uint16Array);
-TestEnumerable(Int16Array);
-TestEnumerable(Uint32Array);
-TestEnumerable(Int32Array);
-TestEnumerable(Float32Array);
-TestEnumerable(Uint8ClampedArray);
+for(i = 0; i < typedArrayConstructors.lenght; i++) {
+  TestEnumerable(typedArrayConstructors[i]);
+}
 
 // Test arbitrary properties on ArrayBuffer
 function TestArbitrary(m) {
   function TestProperty(map, property, value) {
     map[property] = value;
     assertEquals(value, map[property]);
   }
   for (var i = 0; i < 20; i++) {
     TestProperty(m, i, 'val' + i);
     TestProperty(m, 'foo' + i, 'bar' + i);
   }
 }
 TestArbitrary(new ArrayBuffer(256));
+for(i = 0; i < typedArrayConstructors.lenght; i++) {
+  TestArbitary(new typedArrayConstructors[i](10));
+}
+
+
 
 // Test direct constructor call
 assertTrue(ArrayBuffer() instanceof ArrayBuffer);