| // Copyright 2015 the V8 project authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| // Flags: --allow-natives-syntax |
| |
| var typedArrayConstructors = [ |
| Uint8Array, |
| Int8Array, |
| Uint16Array, |
| Int16Array, |
| Uint32Array, |
| Int32Array, |
| Uint8ClampedArray, |
| Float32Array, |
| Float64Array |
| ]; |
| |
| var tmp = { |
| [Symbol.toPrimitive]() { |
| assertUnreachable("Parameter should not be processed when " + |
| "array.[[ViewedArrayBuffer]] is detached."); |
| return 0; |
| } |
| }; |
| |
| for (var constructor of typedArrayConstructors) { |
| var array = new constructor([1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3]); |
| |
| // ---------------------------------------------------------------------- |
| // %TypedArray%.prototype.indexOf. |
| // ---------------------------------------------------------------------- |
| |
| // Negative cases. |
| assertEquals(-1, new constructor([]).indexOf(1)); |
| assertEquals(-1, array.indexOf(4)); |
| assertEquals(-1, array.indexOf(3, array.length)); |
| |
| assertEquals(2, array.indexOf(3)); |
| // Negative index out of range. |
| assertEquals(0, array.indexOf(1, -17)); |
| // Negative index in rage. |
| assertEquals(3, array.indexOf(1, -11)); |
| // Index in range. |
| assertEquals(3, array.indexOf(1, 1)); |
| assertEquals(3, array.indexOf(1, 3)); |
| assertEquals(6, array.indexOf(1, 4)); |
| |
| // Basic TypedArray function properties |
| assertEquals(1, array.indexOf.length); |
| assertThrows(function(){ array.indexOf.call([1], 1); }, TypeError); |
| Object.defineProperty(array, 'length', {value: 1}); |
| assertEquals(array.indexOf(2), 1); |
| |
| // Index of infinite value |
| array = new constructor([NaN, 2, 3, +Infinity, -Infinity, 5, 6]); |
| if (constructor == Float32Array || constructor == Float64Array) { |
| assertEquals(3, array.indexOf(Infinity)); |
| assertEquals(4, array.indexOf(-Infinity)); |
| } else { |
| assertEquals(-1, array.indexOf(Infinity)); |
| assertEquals(-1, array.indexOf(-Infinity)); |
| } |
| assertEquals(-1, array.indexOf(NaN)); |
| |
| // Detached Operation |
| var array = new constructor([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]); |
| %ArrayBufferDetach(array.buffer); |
| assertThrows(() => array.indexOf(tmp), TypeError); |
| |
| // ---------------------------------------------------------------------- |
| // %TypedArray%.prototype.lastIndexOf. |
| // ---------------------------------------------------------------------- |
| array = new constructor([1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3]); |
| |
| // Negative cases. |
| assertEquals(-1, new constructor([]).lastIndexOf(1)); |
| assertEquals(-1, array.lastIndexOf(1, -17)); |
| |
| assertEquals(9, array.lastIndexOf(1)); |
| // Index out of range. |
| assertEquals(9, array.lastIndexOf(1, array.length)); |
| // Index in range. |
| assertEquals(0, array.lastIndexOf(1, 2)); |
| assertEquals(3, array.lastIndexOf(1, 4)); |
| assertEquals(3, array.lastIndexOf(1, 3)); |
| // Negative index in range. |
| assertEquals(0, array.lastIndexOf(1, -11)); |
| |
| // Basic TypedArray function properties |
| assertEquals(1, array.lastIndexOf.length); |
| assertThrows(function(){ array.lastIndexOf.call([1], 1); }, TypeError); |
| Object.defineProperty(array, 'length', {value: 1}); |
| assertEquals(array.lastIndexOf(2), 10); |
| delete array.length; |
| |
| // Index of infinite value |
| array = new constructor([NaN, 2, 3, +Infinity, -Infinity, 5, 6]); |
| if (constructor == Float32Array || constructor == Float64Array) { |
| assertEquals(3, array.lastIndexOf(Infinity)); |
| assertEquals(4, array.lastIndexOf(-Infinity)); |
| } else { |
| assertEquals(-1, array.lastIndexOf(Infinity)); |
| assertEquals(-1, array.lastIndexOf(-Infinity)); |
| } |
| assertEquals(-1, array.lastIndexOf(NaN)); |
| |
| // Detached Operation |
| var array = new constructor([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]); |
| %ArrayBufferDetach(array.buffer); |
| assertThrows(() => array.lastIndexOf(tmp), TypeError); |
| } |