// |reftest| skip-if(!this.hasOwnProperty("SIMD"))
var Float32x4 = SIMD.Float32x4;
var Float64x2 = SIMD.Float64x2;
var Int8x16 = SIMD.Int8x16;
var Int16x8 = SIMD.Int16x8;
var Int32x4 = SIMD.Int32x4;

var {StructType, Handle} = TypedObject;
var {float32, float64, int8, int16, int32, uint8} = TypedObject;

function testFloat32x4Alignment() {
  assertEq(Float32x4.byteLength, 16);
  assertEq(Float32x4.byteAlignment, 16);

  var Compound = new StructType({c: uint8, d: uint8, f: Float32x4});
  assertEq(Compound.fieldOffsets.c, 0);
  assertEq(Compound.fieldOffsets.d, 1);
  assertEq(Compound.fieldOffsets.f, 16);
}

function testFloat32x4Getters() {
  var f = Float32x4(11, 22, 33, 44);
  assertEq(Float32x4.extractLane(f, 0), 11);
  assertEq(Float32x4.extractLane(f, 1), 22);
  assertEq(Float32x4.extractLane(f, 2), 33);
  assertEq(Float32x4.extractLane(f, 3), 44);

  assertThrowsInstanceOf(() => Float32x4.extractLane(f, 4), TypeError);
  assertThrowsInstanceOf(() => Float32x4.extractLane(f, -1), TypeError);
  assertThrowsInstanceOf(() => Float32x4.extractLane(f, 0.5), TypeError);
  assertThrowsInstanceOf(() => Float32x4.extractLane(f, {}), TypeError);
  assertThrowsInstanceOf(() => Float32x4.extractLane(Int32x4(1,2,3,4), 0), TypeError);
  assertThrowsInstanceOf(() => Float32x4.extractLane(1, 0), TypeError);
  assertThrowsInstanceOf(() => Float32x4.extractLane(f, f), TypeError);
}

function testFloat32x4Handles() {
  var Array = Float32x4.array(3);
  var array = new Array([Float32x4(1, 2, 3, 4),
                         Float32x4(5, 6, 7, 8),
                         Float32x4(9, 10, 11, 12)]);

  // Test that trying to create handle into the interior of a
  // Float32x4 fails.
  assertThrowsInstanceOf(function() {
    var h = float32.handle(array, 1, 0);
  }, TypeError, "Creating a float32 handle to elem via ctor");

  assertThrowsInstanceOf(function() {
    var h = float32.handle();
    Handle.move(h, array, 1, 0);
  }, TypeError, "Creating a float32 handle to elem via move");
}

function testFloat32x4Reify() {
  var Array = Float32x4.array(3);
  var array = new Array([Float32x4(1, 2, 3, 4),
                         Float32x4(5, 6, 7, 8),
                         Float32x4(9, 10, 11, 12)]);

  // Test that reading array[1] produces a *copy* of Float32x4, not an
  // alias into the array.

  var f = array[1];
  assertEq(Float32x4.extractLane(f, 3), 8);
  assertEq(Float32x4.extractLane(array[1], 3), 8);
  array[1] = Float32x4(15, 16, 17, 18);
  assertEq(Float32x4.extractLane(f, 3), 8);
  assertEq(Float32x4.extractLane(array[1], 3), 18);
}

function testFloat32x4Setters() {
  var Array = Float32x4.array(3);
  var array = new Array([Float32x4(1, 2, 3, 4),
                         Float32x4(5, 6, 7, 8),
                         Float32x4(9, 10, 11, 12)]);
  assertEq(Float32x4.extractLane(array[1], 3), 8);

  // Test that we are allowed to write Float32x4 values into array,
  // but not other things.

  array[1] = Float32x4(15, 16, 17, 18);
  assertEq(Float32x4.extractLane(array[1], 3), 18);

  assertThrowsInstanceOf(function() {
    array[1] = {x: 15, y: 16, z: 17, w: 18};
  }, TypeError, "Setting Float32x4 from an object");

  assertThrowsInstanceOf(function() {
    array[1] = [15, 16, 17, 18];
  }, TypeError, "Setting Float32x4 from an array");

  assertThrowsInstanceOf(function() {
    array[1] = 22;
  }, TypeError, "Setting Float32x4 from a number");
}

function testFloat64x2Alignment() {
  assertEq(Float64x2.byteLength, 16);
  assertEq(Float64x2.byteAlignment, 16);

  var Compound = new StructType({c: uint8, d: uint8, f: Float64x2});
  assertEq(Compound.fieldOffsets.c, 0);
  assertEq(Compound.fieldOffsets.d, 1);
  assertEq(Compound.fieldOffsets.f, 16);
}

function testFloat64x2Getters() {
  // Create a Float64x2 and check that the getters work:
  var f = Float64x2(11, 22);
  assertEq(Float64x2.extractLane(f, 0), 11);
  assertEq(Float64x2.extractLane(f, 1), 22);

  assertThrowsInstanceOf(() => Float64x2.extractLane(f, 2), TypeError);
  assertThrowsInstanceOf(() => Float64x2.extractLane(f, -1), TypeError);
  assertThrowsInstanceOf(() => Float64x2.extractLane(f, 0.5), TypeError);
  assertThrowsInstanceOf(() => Float64x2.extractLane(f, {}), TypeError);
  assertThrowsInstanceOf(() => Float64x2.extractLane(Float32x4(1,2,3,4), 0), TypeError);
  assertThrowsInstanceOf(() => Float64x2.extractLane(1, 0), TypeError);
  assertThrowsInstanceOf(() => Float64x2.extractLane(f, f), TypeError);
}

function testFloat64x2Handles() {
  var Array = Float64x2.array(3);
  var array = new Array([Float64x2(1, 2),
                         Float64x2(3, 4),
                         Float64x2(5, 6)]);

  // Test that trying to create handle into the interior of a
  // Float64x2 fails.
  assertThrowsInstanceOf(function() {
    var h = float64.handle(array, 1, 0);
  }, TypeError, "Creating a float64 handle to elem via ctor");

  assertThrowsInstanceOf(function() {
    var h = float64.handle();
    Handle.move(h, array, 1, 0);
  }, TypeError, "Creating a float64 handle to elem via move");
}

function testFloat64x2Reify() {
  var Array = Float64x2.array(3);
  var array = new Array([Float64x2(1, 2),
                         Float64x2(3, 4),
                         Float64x2(5, 6)]);

  // Test that reading array[1] produces a *copy* of Float64x2, not an
  // alias into the array.

  var f = array[1];
  assertEq(Float64x2.extractLane(f, 1), 4);
  assertEq(Float64x2.extractLane(array[1], 1), 4);
  array[1] = Float64x2(7, 8);
  assertEq(Float64x2.extractLane(f, 1), 4);
  assertEq(Float64x2.extractLane(array[1], 1), 8);
}

function testFloat64x2Setters() {
  var Array = Float64x2.array(3);
  var array = new Array([Float64x2(1, 2),
                         Float64x2(3, 4),
                         Float64x2(5, 6)]);
  assertEq(Float64x2.extractLane(array[1], 1), 4);

  // Test that we are allowed to write Float64x2 values into array,
  // but not other things.

  array[1] = Float64x2(7, 8);
  assertEq(Float64x2.extractLane(array[1], 1), 8);

  assertThrowsInstanceOf(function() {
    array[1] = {x: 7, y: 8 };
  }, TypeError, "Setting Float64x2 from an object");

  assertThrowsInstanceOf(function() {
    array[1] = [ 7, 8 ];
  }, TypeError, "Setting Float64x2 from an array");

  assertThrowsInstanceOf(function() {
    array[1] = 9;
  }, TypeError, "Setting Float64x2 from a number");
}

function testInt8x16Alignment() {
  assertEq(Int8x16.byteLength, 16);
  assertEq(Int8x16.byteAlignment, 16);

  var Compound = new StructType({c: uint8, d: uint8, f: Int8x16});
  assertEq(Compound.fieldOffsets.c, 0);
  assertEq(Compound.fieldOffsets.d, 1);
  assertEq(Compound.fieldOffsets.f, 16);
}

function testInt8x16Getters() {
  // Create a Int8x16 and check that the getters work:
  var f = Int8x16(11, 22, 33, 44, 55, 66, 77, 88, 99, 10, 20, 30, 40, 50, 60, 70);
  assertEq(Int8x16.extractLane(f, 0), 11);
  assertEq(Int8x16.extractLane(f, 1), 22);
  assertEq(Int8x16.extractLane(f, 2), 33);
  assertEq(Int8x16.extractLane(f, 3), 44);
  assertEq(Int8x16.extractLane(f, 4), 55);
  assertEq(Int8x16.extractLane(f, 5), 66);
  assertEq(Int8x16.extractLane(f, 6), 77);
  assertEq(Int8x16.extractLane(f, 7), 88);
  assertEq(Int8x16.extractLane(f, 8), 99);
  assertEq(Int8x16.extractLane(f, 9), 10);
  assertEq(Int8x16.extractLane(f, 10), 20);
  assertEq(Int8x16.extractLane(f, 11), 30);
  assertEq(Int8x16.extractLane(f, 12), 40);
  assertEq(Int8x16.extractLane(f, 13), 50);
  assertEq(Int8x16.extractLane(f, 14), 60);
  assertEq(Int8x16.extractLane(f, 15), 70);

  assertThrowsInstanceOf(() => Int8x16.extractLane(f, 16), TypeError);
  assertThrowsInstanceOf(() => Int8x16.extractLane(f, -1), TypeError);
  assertThrowsInstanceOf(() => Int8x16.extractLane(f, 0.5), TypeError);
  assertThrowsInstanceOf(() => Int8x16.extractLane(f, {}), TypeError);
  assertThrowsInstanceOf(() => Int8x16.extractLane(Int32x4(1,2,3,4), 0), TypeError);
  assertThrowsInstanceOf(() => Int8x16.extractLane(1, 0), TypeError);
  assertThrowsInstanceOf(() => Int8x16.extractLane(f, f), TypeError);
}

function testInt8x16Handles() {
  var Array = Int8x16.array(3);
  var array = new Array([Int8x16(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16),
                         Int8x16(17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32),
                         Int8x16(33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48)]);

  // Test that trying to create handle into the interior of a
  // Int8x16 fails.
  assertThrowsInstanceOf(function() {
    var h = int8.handle(array, 1, 0);
  }, TypeError, "Creating a int8 handle to elem via ctor");

  assertThrowsInstanceOf(function() {
    var h = int8.handle();
    Handle.move(h, array, 1, 0);
  }, TypeError, "Creating a int8 handle to elem via move");
}

function testInt8x16Reify() {
  var Array = Int8x16.array(3);
  var array = new Array([Int8x16(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16),
                         Int8x16(17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32),
                         Int8x16(33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48)]);

  // Test that reading array[1] produces a *copy* of Int8x16, not an
  // alias into the array.

  var f = array[1];
  assertEq(Int8x16.extractLane(f, 3), 20);
  assertEq(Int8x16.extractLane(array[1], 3), 20);
  array[1] = Int8x16(49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64);
  assertEq(Int8x16.extractLane(f, 3), 20);
  assertEq(Int8x16.extractLane(array[1], 3), 52);
}

function testInt8x16Setters() {
  var Array = Int8x16.array(3);
  var array = new Array([Int8x16(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16),
                         Int8x16(17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32),
                         Int8x16(33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48)]);
  assertEq(Int8x16.extractLane(array[1], 3), 20);

  // Test that we are allowed to write Int8x16 values into array,
  // but not other things.

  array[1] = Int8x16(49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64);
  assertEq(Int8x16.extractLane(array[1], 3), 52);

  assertThrowsInstanceOf(function() {
    array[1] = {s0: 49, s1: 50, s2: 51, s3: 52, s4: 53, s5: 54, s6: 55, s7: 56,
                s8: 57, s9: 58, s10: 59, s11: 60, s12: 61, s13: 62, s14: 63, s15: 64};
  }, TypeError, "Setting Int8x16 from an object");

  assertThrowsInstanceOf(function() {
    array[1] = [49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64];
  }, TypeError, "Setting Int8x16 from an array");

  assertThrowsInstanceOf(function() {
    array[1] = 52;
  }, TypeError, "Setting Int8x16 from a number");
}

function testInt16x8Alignment() {
  assertEq(Int16x8.byteLength, 16);
  assertEq(Int16x8.byteAlignment, 16);

  var Compound = new StructType({c: uint8, d: uint8, f: Int16x8});
  assertEq(Compound.fieldOffsets.c, 0);
  assertEq(Compound.fieldOffsets.d, 1);
  assertEq(Compound.fieldOffsets.f, 16);
}

function testInt16x8Getters() {
  // Create a Int16x8 and check that the getters work:
  var f = Int16x8(11, 22, 33, 44, 55, 66, 77, 88);
  assertEq(Int16x8.extractLane(f, 0), 11);
  assertEq(Int16x8.extractLane(f, 1), 22);
  assertEq(Int16x8.extractLane(f, 2), 33);
  assertEq(Int16x8.extractLane(f, 3), 44);
  assertEq(Int16x8.extractLane(f, 4), 55);
  assertEq(Int16x8.extractLane(f, 5), 66);
  assertEq(Int16x8.extractLane(f, 6), 77);
  assertEq(Int16x8.extractLane(f, 7), 88);

  assertThrowsInstanceOf(() => Int16x8.extractLane(f, 8), TypeError);
  assertThrowsInstanceOf(() => Int16x8.extractLane(f, -1), TypeError);
  assertThrowsInstanceOf(() => Int16x8.extractLane(f, 0.5), TypeError);
  assertThrowsInstanceOf(() => Int16x8.extractLane(f, {}), TypeError);
  assertThrowsInstanceOf(() => Int16x8.extractLane(Int32x4(1,2,3,4), 0), TypeError);
  assertThrowsInstanceOf(() => Int16x8.extractLane(1, 0), TypeError);
  assertThrowsInstanceOf(() => Int16x8.extractLane(f, f), TypeError);
}

function testInt16x8Handles() {
  var Array = Int16x8.array(3);
  var array = new Array([Int16x8(1, 2, 3, 4, 5, 6, 7, 8),
                         Int16x8(9, 10, 11, 12, 13, 14, 15, 16),
                         Int16x8(17, 18, 19, 20, 21, 22, 23, 24)]);

  // Test that trying to create handle into the interior of a
  // Int16x8 fails.
  assertThrowsInstanceOf(function() {
    var h = int16.handle(array, 1, 0);
  }, TypeError, "Creating a int16 handle to elem via ctor");

  assertThrowsInstanceOf(function() {
    var h = int16.handle();
    Handle.move(h, array, 1, 0);
  }, TypeError, "Creating a int16 handle to elem via move");
}

function testInt16x8Reify() {
  var Array = Int16x8.array(3);
  var array = new Array([Int16x8(1, 2, 3, 4, 5, 6, 7, 8),
                         Int16x8(9, 10, 11, 12, 13, 14, 15, 16),
                         Int16x8(17, 18, 19, 20, 21, 22, 23, 24)]);

  // Test that reading array[1] produces a *copy* of Int16x8, not an
  // alias into the array.

  var f = array[1];
  assertEq(Int16x8.extractLane(f, 3), 12);
  assertEq(Int16x8.extractLane(array[1], 3), 12);
  array[1] = Int16x8(25, 26, 27, 28, 29, 30, 31, 32);
  assertEq(Int16x8.extractLane(f, 3), 12);
  assertEq(Int16x8.extractLane(array[1], 3), 28);
}

function testInt16x8Setters() {
  var Array = Int16x8.array(3);
  var array = new Array([Int16x8(1, 2, 3, 4, 5, 6, 7, 8),
                         Int16x8(9, 10, 11, 12, 13, 14, 15, 16),
                         Int16x8(17, 18, 19, 20, 21, 22, 23, 24)]);
  assertEq(Int16x8.extractLane(array[1], 3), 12);

  // Test that we are allowed to write Int16x8 values into array,
  // but not other things.

  array[1] = Int16x8(25, 26, 27, 28, 29, 30, 31, 32);
  assertEq(Int16x8.extractLane(array[1], 3), 28);

  assertThrowsInstanceOf(function() {
    array[1] = {s0: 25, s1: 26, s2: 27, s3: 28, s4: 29, s5: 30, s6: 31, s7: 32};
  }, TypeError, "Setting Int16x8 from an object");

  assertThrowsInstanceOf(function() {
    array[1] = [25, 26, 27, 28, 29, 30, 31, 32];
  }, TypeError, "Setting Int16x8 from an array");

  assertThrowsInstanceOf(function() {
    array[1] = 28;
  }, TypeError, "Setting Int16x8 from a number");
}

function testInt32x4Alignment() {
  assertEq(Int32x4.byteLength, 16);
  assertEq(Int32x4.byteAlignment, 16);

  var Compound = new StructType({c: uint8, d: uint8, f: Int32x4});
  assertEq(Compound.fieldOffsets.c, 0);
  assertEq(Compound.fieldOffsets.d, 1);
  assertEq(Compound.fieldOffsets.f, 16);
}

function testInt32x4Getters() {
  // Create a Int32x4 and check that the getters work:
  var f = Int32x4(11, 22, 33, 44);
  assertEq(Int32x4.extractLane(f, 0), 11);
  assertEq(Int32x4.extractLane(f, 1), 22);
  assertEq(Int32x4.extractLane(f, 2), 33);
  assertEq(Int32x4.extractLane(f, 3), 44);

  assertThrowsInstanceOf(() => Int32x4.extractLane(f, 4), TypeError);
  assertThrowsInstanceOf(() => Int32x4.extractLane(f, -1), TypeError);
  assertThrowsInstanceOf(() => Int32x4.extractLane(f, 0.5), TypeError);
  assertThrowsInstanceOf(() => Int32x4.extractLane(f, {}), TypeError);
  assertThrowsInstanceOf(() => Int32x4.extractLane(Float32x4(1,2,3,4), 0), TypeError);
  assertThrowsInstanceOf(() => Int32x4.extractLane(1, 0), TypeError);
  assertThrowsInstanceOf(() => Int32x4.extractLane(f, f), TypeError);
}

function testInt32x4Handles() {
  var Array = Int32x4.array(3);
  var array = new Array([Int32x4(1, 2, 3, 4),
                         Int32x4(5, 6, 7, 8),
                         Int32x4(9, 10, 11, 12)]);

  // Test that trying to create handle into the interior of a
  // Int32x4 fails.
  assertThrowsInstanceOf(function() {
    var h = int32.handle(array, 1, 0);
  }, TypeError, "Creating a int32 handle to elem via ctor");

  assertThrowsInstanceOf(function() {
    var h = int32.handle();
    Handle.move(h, array, 1, 0);
  }, TypeError, "Creating a int32 handle to elem via move");
}

function testInt32x4Reify() {
  var Array = Int32x4.array(3);
  var array = new Array([Int32x4(1, 2, 3, 4),
                         Int32x4(5, 6, 7, 8),
                         Int32x4(9, 10, 11, 12)]);

  // Test that reading array[1] produces a *copy* of Int32x4, not an
  // alias into the array.

  var f = array[1];
  assertEq(Int32x4.extractLane(f, 3), 8);
  assertEq(Int32x4.extractLane(array[1], 3), 8);
  array[1] = Int32x4(15, 16, 17, 18);
  assertEq(Int32x4.extractLane(f, 3), 8);
  assertEq(Int32x4.extractLane(array[1], 3), 18);
}

function testInt32x4Setters() {
  var Array = Int32x4.array(3);
  var array = new Array([Int32x4(1, 2, 3, 4),
                         Int32x4(5, 6, 7, 8),
                         Int32x4(9, 10, 11, 12)]);
  assertEq(Int32x4.extractLane(array[1], 3), 8);

  // Test that we are allowed to write Int32x4 values into array,
  // but not other things.
  array[1] = Int32x4(15, 16, 17, 18);
  assertEq(Int32x4.extractLane(array[1], 3), 18);

  assertThrowsInstanceOf(function() {
    array[1] = {x: 15, y: 16, z: 17, w: 18};
  }, TypeError, "Setting Int32x4 from an object");

  assertThrowsInstanceOf(function() {
    array[1] = [15, 16, 17, 18];
  }, TypeError, "Setting Int32x4 from an array");

  assertThrowsInstanceOf(function() {
    array[1] = 22;
  }, TypeError, "Setting Int32x4 from a number");
}

function test() {
  testFloat32x4Alignment();
  testFloat32x4Getters();
  testFloat32x4Handles();
  testFloat32x4Reify();
  testFloat32x4Setters();

  testFloat64x2Alignment();
  testFloat64x2Getters();
  testFloat64x2Handles();
  testFloat64x2Reify();
  testFloat64x2Setters();

  testInt8x16Alignment();
  testInt8x16Getters();
  testInt8x16Handles();
  testInt8x16Reify();
  testInt8x16Setters();

  testInt16x8Alignment();
  testInt16x8Getters();
  testInt16x8Handles();
  testInt16x8Reify();
  testInt16x8Setters();

  testInt32x4Alignment();
  testInt32x4Getters();
  testInt32x4Handles();
  testInt32x4Reify();
  testInt32x4Setters();

  if (typeof reportCompare === "function") {
    reportCompare(true, true);
  }
}

test();