Update mjsunit tests to be complaint with ES6 implementation of typed arrays

test/mjsunit/external-array.js

 // Copyright 2012 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 31 matching lines @@
 var a = new Int32Array(2);
 for (var i = 0; i < 5; i++) {
   f(a);
 }
 %OptimizeFunctionOnNextCall(f);
 f(a);
 
 assertEquals(0, a[0]);
 assertEquals(0, a[1]);
 
-// No-parameter constructor should fail right now.
-function abfunc1() {
-  return new ArrayBuffer();
-}
-assertThrows(abfunc1);
-
 // Test derivation from an ArrayBuffer
 var ab = new ArrayBuffer(12);
 assertInstance(ab, ArrayBuffer);
 var derived_uint8 = new Uint8Array(ab);
 assertInstance(derived_uint8, Uint8Array);
 assertSame(ab, derived_uint8.buffer);
 assertEquals(12, derived_uint8.length);
 assertEquals(12, derived_uint8.byteLength);
 assertEquals(0, derived_uint8.byteOffset);
 assertEquals(1, derived_uint8.BYTES_PER_ELEMENT);
@@ skipping 86 matching lines @@
 assertEquals(a.byteLength, a.buffer.byteLength);
 assertEquals(a.length * a.BYTES_PER_ELEMENT, a.buffer.byteLength);
 
 // Test that an implicitly created buffer is a valid buffer.
 a = new Float64Array(7);
 assertSame(a.buffer, (new Uint16Array(a.buffer)).buffer);
 assertSame(a.buffer, (new Float32Array(a.buffer,4)).buffer);
 assertSame(a.buffer, (new Int8Array(a.buffer,3,51)).buffer);
 assertInstance(a.buffer, ArrayBuffer);
 
-// Test the correct behavior of the |BYTES_PER_ELEMENT| property (which is
-// "constant", but not read-only).
+// Test the correct behavior of the |BYTES_PER_ELEMENT| property
 a = new Int32Array(2);
 assertEquals(4, a.BYTES_PER_ELEMENT);
-a.BYTES_PER_ELEMENT = 42;
-assertEquals(42, a.BYTES_PER_ELEMENT);
 a = new Uint8Array(2);
 assertEquals(1, a.BYTES_PER_ELEMENT);
 a = new Int16Array(2);
 assertEquals(2, a.BYTES_PER_ELEMENT);
 
 // Test Float64Arrays.
 function get(a, index) {
   return a[index];
 }
 function set(a, index, value) {
@@ skipping 15 matching lines @@
   assertEquals(3.5, array[1]);
 }
 %OptimizeFunctionOnNextCall(get);
 assertEquals(2.5, get(array, 0));
 assertEquals(3.5, get(array, 1));
 }
 
 // Test non-number parameters.
 var array_with_length_from_non_number = new Int32Array("2");
 assertEquals(2, array_with_length_from_non_number.length);
-array_with_length_from_non_number = new Int32Array(undefined);
-assertEquals(0, array_with_length_from_non_number.length);
-var foo = { valueOf: function() { return 3; } };
-array_with_length_from_non_number = new Int32Array(foo);
-assertEquals(3, array_with_length_from_non_number.length);
-foo = { toString: function() { return "4"; } };
-array_with_length_from_non_number = new Int32Array(foo);
-assertEquals(4, array_with_length_from_non_number.length);
-
 
 // Test loads and stores.
 types = [Array, Int8Array, Uint8Array, Int16Array, Uint16Array, Int32Array,
          Uint32Array, Uint8ClampedArray, Float32Array, Float64Array];
 
 test_result_nan = [NaN, 0, 0, 0, 0, 0, 0, 0, NaN, NaN];
 test_result_low_int = [-1, -1, 255, -1, 65535, -1, 0xFFFFFFFF, 0, -1, -1];
 test_result_low_double = [-1.25, -1, 255, -1, 65535, -1, 0xFFFFFFFF, 0, -1.25, -1.25];
 test_result_middle = [253.75, -3, 253, 253, 253, 253, 253, 254, 253.75, 253.75];
 test_result_high_int = [256, 0, 0, 256, 256, 256, 256, 255, 256, 256];
@@ skipping 128 matching lines @@
   run_test(test_store_middle_tagged, a, test_result_middle[t]);
   run_test(test_store_high_double, a, test_result_high_double[t]);
   run_test(test_store_high_tagged, a, test_result_high_double[t]);
 
   // Test the correct behavior of the |length| property (which is read-only).
   if (t != 0) {
     assertEquals(kElementCount, a.length);
     a.length = 2;
     assertEquals(kElementCount, a.length);
     assertTrue(delete a.length);
-    a.length = 2;
-    assertEquals(2, a.length);
 
     // Make sure bounds checks are handled correctly for external arrays.
     run_bounds_test(a);
     run_bounds_test(a);
     run_bounds_test(a);
     %OptimizeFunctionOnNextCall(run_bounds_test);
     run_bounds_test(a);
     %DeoptimizeFunction(run_bounds_test);
     gc();  // Makes V8 forget about type information for test_func.
 
@@ skipping 71 matching lines @@
 assertEquals(0, a.length);
 a[0] = 1;
 assertEquals(undefined, a[0]);
 a = new Uint16Array(0);
 assertInstance(a, Uint16Array);
 assertEquals(0, a.byteLength);
 assertEquals(0, a.length);
 a[0] = 1;
 assertEquals(undefined, a[0]);
 
-
 // Check construction from arrays.
 a = new Uint32Array([]);
 assertInstance(a, Uint32Array);
 assertEquals(0, a.length);
 assertEquals(0, a.byteLength);
 assertEquals(0, a.buffer.byteLength);
 assertEquals(4, a.BYTES_PER_ELEMENT);
 assertInstance(a.buffer, ArrayBuffer);
 a = new Uint16Array([1,2,3]);
 assertInstance(a, Uint16Array);
@@ skipping 66 matching lines @@
 assertSame(a.buffer, aa.buffer);
 aa = a.subarray(0,-8);
 assertInstance(aa, Uint16Array);
 assertEquals(0, aa.length);
 assertEquals(0, aa.byteLength);
 assertEquals(2, aa.BYTES_PER_ELEMENT);
 assertSame(a.buffer, aa.buffer);
 
 assertThrows(function(){ a.subarray.call({}, 0) });
 assertThrows(function(){ a.subarray.call([], 0) });
-assertThrows(function(){ a.subarray.call(a) });
-
 
 // Call constructors directly as functions, and through .call and .apply
 
 b = ArrayBuffer(100)
 a = Int8Array(b, 5, 77)
 assertInstance(b, ArrayBuffer)
 assertInstance(a, Int8Array)
 assertSame(b, a.buffer)
 assertEquals(5, a.byteOffset)
 assertEquals(77, a.byteLength)
@@ skipping 153 matching lines @@
 
 built_in_array = new Array(1.5, 2, 3, 4, 5, 6);
 assertEquals(1.5, goo(built_in_array, 0));
 assertEquals(1.5, goo(built_in_array, 0));
 %OptimizeFunctionOnNextCall(goo);
 %OptimizeFunctionOnNextCall(boo);
 boo(built_in_array, 0, 2.5);
 assertEquals(2.5, goo(built_in_array, 0));
 %ClearFunctionTypeFeedback(goo);
 %ClearFunctionTypeFeedback(boo);