// Copyright 2018 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 intarray = new BigInt64Array(8);
var uintarray = new BigUint64Array(8);

function test(f) {
  %PrepareFunctionForOptimization(f);
  f();
  f();  // Make sure we test ICs.
  f();
  %OptimizeFunctionOnNextCall(f);
  f();
}

function test_both(f) {
  test(() => f(BigInt64Array));
  test(() => f(BigUint64Array));
}

test(function basic_assignment() {
  const x = 0x1234567890abcdefn;
  intarray[0] = x;
  assertEquals(x, intarray[0]);
  uintarray[0] = x;
  assertEquals(x, uintarray[0]);
  const y = -0x76543210fedcba98n;
  intarray[0] = y;
  assertEquals(y, intarray[0]);
});

test(function construct() {
  var a = new BigInt64Array([1n, -2n, {valueOf: () => 3n}]);
  assertArrayEquals([1n, -2n, 3n], a);
  assertThrows(() => new BigInt64Array([4, 5]), TypeError);
  var b = new BigUint64Array([6n, -7n]);
  assertArrayEquals([6n, 0xfffffffffffffff9n], b);
  var c = new BigUint64Array(new BigInt64Array([8n, -9n]));
  assertArrayEquals([8n, 0xfffffffffffffff7n], c);
  var d = new BigInt64Array(new BigUint64Array([10n, 0xfffffffffffffff5n]));
  assertArrayEquals([10n, -11n], d);
  assertThrows(() => new BigInt64Array(new Int32Array([12, 13])), TypeError);
  assertThrows(() => new Int32Array(new BigInt64Array([14n, -15n])), TypeError);
});

test_both(function copyWithin(BigArray) {
  var a = BigArray.of(1n, 2n, 3n);
  a.copyWithin(0, 1, 3);
  assertArrayEquals([2n, 3n, 3n], a);
});

test_both(function entries(BigArray) {
  var a = BigArray.of(1n, 2n, 3n);
  var it = a.entries();
  assertEquals([0, 1n], it.next().value);
  assertEquals([1, 2n], it.next().value);
  assertEquals([2, 3n], it.next().value);
  assertTrue(it.next().done);
});

test_both(function every(BigArray) {
  var a = BigArray.of(2n, 3n, 4n);
  var seen = [];
  assertTrue(a.every((x) => {seen.push(x); return x > 1n}));
  assertEquals([2n, 3n, 4n], seen);
});

test_both(function fill(BigArray) {
  var a = BigArray.of(1n, 2n, 3n, 4n);
  a.fill(7n, 1, 3);
  assertArrayEquals([1n, 7n, 7n, 4n], a);
  assertThrows(() => (new BigArray(3).fill(1)), TypeError);
});

test_both(function filter(BigArray) {
  var a = BigArray.of(1n, 3n, 4n, 2n);
  var b = a.filter((x) => x > 2n);
  assertArrayEquals([3n, 4n], b);
});

test_both(function find(BigArray) {
  var a = BigArray.of(1n, 2n, 3n);
  assertEquals(2n, a.find((x) => x === 2n));
  assertEquals(undefined, a.find((x) => x === 2));
});

test_both(function findIndex(BigArray) {
  var a = BigArray.of(1n, 2n, 3n);
  assertEquals(1, a.findIndex((x) => x === 2n));
  assertEquals(-1, a.findIndex((x) => x === 2));
});

test_both(function forEach(BigArray) {
  var a = BigArray.of(1n, 2n, 3n);
  var seen = [];
  a.forEach((x) => seen.push(x));
  assertEquals([1n, 2n, 3n], seen);
});

test_both(function from(BigArray) {
  var a = BigArray.of(1n, 2n, 3n);
  var b = BigArray.from(a);
  assertArrayEquals([1n, 2n, 3n], b);
  assertThrows(() => BigArray.from([4, 5]), TypeError);
  var c = BigArray.from([6, 7], BigInt);
  assertArrayEquals([6n, 7n], c);
  assertThrows(() => Int32Array.from([4n, 5n]), TypeError);
  assertThrows(() => Int32Array.from([4, 5], BigInt), TypeError);
});

test(function from_mixed() {
  var contents = [1n, 2n, 3n];
  var a = new BigInt64Array(contents);
  var b = BigUint64Array.from(a);
  assertArrayEquals(contents, b);
  var c = BigInt64Array.from(b);
  assertArrayEquals(contents, c);
});

test_both(function includes(BigArray) {
  var a = BigArray.of(0n, 1n, 2n);
  assertTrue(a.includes(1n));
  assertFalse(a.includes(undefined));
  assertFalse(a.includes(1));
  assertFalse(a.includes(0x1234567890abcdef123n));  // More than 64 bits.
});

test_both(function indexOf(BigArray) {
  var a = BigArray.of(0n, 1n, 2n);
  assertEquals(1, a.indexOf(1n));
  assertEquals(-1, a.indexOf(undefined));
  assertEquals(-1, a.indexOf(1));
  assertEquals(-1, a.indexOf(0x1234567890abcdef123n));  // More than 64 bits.
});

test_both(function join(BigArray) {
  var a = BigArray.of(1n, 2n, 3n);
  assertEquals("1-2-3", a.join("-"));
});

test_both(function keys(BigArray) {
  var a = BigArray.of(1n, 2n, 3n);
  var it = a.keys();
  assertEquals(0, it.next().value);
  assertEquals(1, it.next().value);
  assertEquals(2, it.next().value);
  assertTrue(it.next().done);
});

test_both(function lastIndexOf(BigArray) {
  var a = BigArray.of(0n, 1n, 2n);
  assertEquals(1, a.lastIndexOf(1n));
  assertEquals(-1, a.lastIndexOf(undefined));
  assertEquals(-1, a.lastIndexOf(1));
  assertEquals(-1, a.lastIndexOf(0x1234567890abcdef123n));  // > 64 bits.
});

test_both(function map(BigArray) {
  var a = BigArray.of(1n, 2n, 3n);
  var b = a.map((x) => 2n * x);
  assertEquals(BigArray, b.constructor);
  assertArrayEquals([2n, 4n, 6n], b);
});

test_both(function of(BigArray) {
  var a = BigArray.of(true, 2n, {valueOf: () => 3n}, "4");
  assertArrayEquals([1n, 2n, 3n, 4n], a);
  assertThrows(() => BigArray.of(1), TypeError)
  assertThrows(() => BigArray.of(undefined), TypeError)
});

test_both(function reduce(BigArray) {
  var a = BigArray.of(1n, 2n, 3n);
  assertEquals(6n, a.reduce((sum, x) => sum + x, 0n));
});

test_both(function reduceRight(BigArray) {
  var a = BigArray.of(1n, 2n, 3n);
  assertEquals(6n, a.reduce((sum, x) => sum + x, 0n));
});

test_both(function reverse(BigArray) {
  var a = BigArray.of(1n, 2n, 3n);
  a.reverse();
  assertArrayEquals([3n, 2n, 1n], a);
});

test_both(function set(BigArray) {
  var a = new BigArray(7);
  a.set(BigArray.of(1n, 2n, 3n), 2);
  assertArrayEquals([0n, 0n, 1n, 2n, 3n, 0n, 0n], a);
  a.set([4n, 5n, 6n], 1);
  assertArrayEquals([0n, 4n, 5n, 6n, 3n, 0n, 0n], a);
  assertThrows(() => a.set([7, 8, 9], 3), TypeError);
  assertThrows(() => a.set(Int32Array.of(10, 11), 2), TypeError);

  var Other = BigArray == BigInt64Array ? BigUint64Array : BigInt64Array;
  a.set(Other.of(12n, 13n), 4);
  assertArrayEquals([0n, 4n, 5n, 6n, 12n, 13n, 0n], a);
});

test_both(function slice(BigArray) {
  var a = BigArray.of(1n, 2n, 3n, 4n);
  var b = a.slice(1, 3);
  assertArrayEquals([2n, 3n], b);
});

test_both(function some(BigArray) {
  var a = BigArray.of(1n, 2n, 3n);
  assertTrue(a.some((x) => x === 2n));
});

test_both(function sort(BigArray) {
  var a = BigArray.of(7n, 2n, 5n, 3n);
  a.sort();
  assertArrayEquals([2n, 3n, 5n, 7n], a);
});

test_both(function subarray(BigArray) {
  var a = BigArray.of(1n, 2n, 3n, 4n);
  var b = a.subarray(1, 3);
  assertEquals(BigArray, b.constructor);
  assertArrayEquals([2n, 3n], b);
});

test_both(function toString(BigArray) {
  var a = BigArray.of(1n, 2n, 3n);
  assertEquals("1,2,3", a.toString());
});

test_both(function values(BigArray) {
  var a = BigArray.of(1n, 2n, 3n);
  var it = a.values();
  assertEquals(1n, it.next().value);
  assertEquals(2n, it.next().value);
  assertEquals(3n, it.next().value);
  assertTrue(it.next().done);
});