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

function testFloat32x4add() {
  function addf(a, b) {
    return Math.fround(Math.fround(a) + Math.fround(b));
  }

  var vals = [
    [[1, 2, 3, 4], [10, 20, 30, 40]],
    [[1.57, 2.27, 3.57, 4.19], [10.31, 20.49, 30.41, 40.72]],
    [[NaN, -0, Infinity, -Infinity], [0, -0, -Infinity, -Infinity]]
  ];

  for (var [v,w] of vals) {
    testBinaryFunc(Float32x4(...v), Float32x4(...w), Float32x4.add, addf);
  }
}

function testFloat32x4and() {
  var andf = (function() {
    var i = new Int32Array(3);
    var f = new Float32Array(i.buffer);
    return function(x, y) {
      f[0] = x;
      f[1] = y;
      i[2] = i[0] & i[1];
      return f[2];
    };
  })();

  var vals = [
    [[1, 2, 3, 4], [10, 20, 30, 40]],
    [[1.51, 2.98, 3.65, 4.34], [10.29, 20.12, 30.79, 40.41]],
    [[NaN, -0, Infinity, -Infinity], [NaN, -0, -Infinity, Infinity]]
  ];

  for (var [v,w] of vals) {
    testBinaryFunc(Float32x4(...v), Float32x4(...w), Float32x4.and, andf);
  }
}

function testFloat32x4div() {
  function divf(a, b) {
    return Math.fround(Math.fround(a) / Math.fround(b));
  }

  var vals = [
    [[1, 2, 3, 4], [10, 20, 30, 40]],
    [[1.26, 2.03, 3.17, 4.59], [11.025, 17.3768, 29.1957, 46.4049]],
    [[0, -0, Infinity, -Infinity], [1, 1, -Infinity, Infinity]]
  ];

  for (var [v,w] of vals) {
    testBinaryFunc(Float32x4(...v), Float32x4(...w), Float32x4.div, divf);
  }
}

function testFloat32x4mul() {
  function mulf(a, b) {
    return Math.fround(Math.fround(a) * Math.fround(b));
  }

  var vals = [
    [[1, 2, 3, 4], [10, 20, 30, 40]],
    [[1.66, 2.57, 3.73, 4.12], [10.67, 20.68, 30.02, 40.58]],
    [[NaN, -0, Infinity, -Infinity], [NaN, -0, -Infinity, 0]]
  ];

  for (var [v,w] of vals) {
    testBinaryFunc(Float32x4(...v), Float32x4(...w), Float32x4.mul, mulf);
  }
}

function testFloat32x4or() {
  var orf = (function() {
    var i = new Int32Array(3);
    var f = new Float32Array(i.buffer);
    return function(x, y) {
      f[0] = x;
      f[1] = y;
      i[2] = i[0] | i[1];
      return f[2];
    };
  })();

  var vals = [
    [[1, 2, 3, 4], [10, 20, 30, 40]],
    [[1.12, 2.39, 3.83, 4.57], [10.76, 20.41, 30.96, 40.23]],
    [[NaN, -0, Infinity, -Infinity], [5, 5, -Infinity, Infinity]]
  ];

  for (var [v,w] of vals) {
    testBinaryFunc(Float32x4(...v), Float32x4(...w), Float32x4.or, orf);
  }
}

function testFloat32x4sub() {
  function subf(a, b) {
    return Math.fround(Math.fround(a) - Math.fround(b));
  }

  var vals = [
    [[1, 2, 3, 4], [10, 20, 30, 40]],
    [[1.34, 2.95, 3.17, 4.29], [10.18, 20.43, 30.63, 40.38]],
    [[NaN, -0, -Infinity, -Infinity], [NaN, -0, Infinity, -Infinity]]
  ];

  for (var [v,w] of vals) {
    testBinaryFunc(Float32x4(...v), Float32x4(...w), Float32x4.sub, subf);
  }
}

function testFloat32x4xor() {
  var xorf = (function() {
    var i = new Int32Array(3);
    var f = new Float32Array(i.buffer);
    return function(x, y) {
      f[0] = x;
      f[1] = y;
      i[2] = i[0] ^ i[1];
      return f[2];
    };
  })();

  var vals = [
    [[1, 2, 3, 4], [10, 20, 30, 40]],
    [[1.07, 2.62, 3.79, 4.15], [10.38, 20.47, 30.44, 40.16]],
    [[NaN, -0, Infinity, -Infinity], [-0, Infinity, -Infinity, NaN]]
  ];

  for (var [v,w] of vals) {
    testBinaryFunc(Float32x4(...v), Float32x4(...w), Float32x4.xor, xorf);
  }
}

var i8x16vals = [
  [[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16],
   [10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120, 130, 140, 150, 160]],
  [[INT8_MAX, INT8_MIN, INT8_MAX, INT8_MIN, INT8_MAX, INT8_MIN, INT8_MAX, INT8_MIN, -2, -3, -4, -5, -6, -7, -8, -9],
   [1, 1, -1, -1, INT8_MAX, INT8_MAX, INT8_MIN, INT8_MIN, 8, 9, 10, 11, 12, 13, 14, 15]]
];

function testInt8x16add() {
  function addi(a, b) {
    return (a + b) << 24 >> 24;
  }

  for (var [v,w] of i8x16vals) {
    testBinaryFunc(Int8x16(...v), Int8x16(...w), Int8x16.add, addi);
  }
}

function testInt8x16and() {
  function andi(a, b) {
    return (a & b) << 24 >> 24;
  }

  for (var [v,w] of i8x16vals) {
    testBinaryFunc(Int8x16(...v), Int8x16(...w), Int8x16.and, andi);
  }
}

function testInt8x16mul() {
  function muli(x, y) {
    return (x * y) << 24 >> 24;
  }

  for (var [v,w] of i8x16vals) {
    testBinaryFunc(Int8x16(...v), Int8x16(...w), Int8x16.mul, muli);
  }
}

function testInt8x16or() {
  function ori(a, b) {
    return (a | b) << 24 >> 24;
  }

  for (var [v,w] of i8x16vals) {
    testBinaryFunc(Int8x16(...v), Int8x16(...w), Int8x16.or, ori);
  }
}

function testInt8x16sub() {
  function subi(a, b) {
    return (a - b) << 24 >> 24;
  }

  for (var [v,w] of i8x16vals) {
    testBinaryFunc(Int8x16(...v), Int8x16(...w), Int8x16.sub, subi);
  }
}

function testInt8x16xor() {
  function xori(a, b) {
    return (a ^ b) << 24 >> 24;
  }

  for (var [v,w] of i8x16vals) {
    testBinaryFunc(Int8x16(...v), Int8x16(...w), Int8x16.xor, xori);
  }
}

var i16x8vals = [
  [[1, 2, 3, 4, 5, 6, 7, 8],
   [10, 20, 30, 40, 50, 60, 70, 80]],
  [[INT16_MAX, INT16_MIN, INT16_MAX, INT16_MIN, INT16_MAX, INT16_MIN, INT16_MAX, INT16_MIN],
   [1, 1, -1, -1, INT16_MAX, INT16_MAX, INT16_MIN, INT16_MIN]]
];

function testInt16x8add() {
  function addi(a, b) {
    return (a + b) << 16 >> 16;
  }

  for (var [v,w] of i16x8vals) {
    testBinaryFunc(Int16x8(...v), Int16x8(...w), Int16x8.add, addi);
  }
}

function testInt16x8and() {
  function andi(a, b) {
    return (a & b) << 16 >> 16;
  }

  for (var [v,w] of i16x8vals) {
    testBinaryFunc(Int16x8(...v), Int16x8(...w), Int16x8.and, andi);
  }
}

function testInt16x8mul() {
  function muli(x, y) {
    return (x * y) << 16 >> 16;
  }

  for (var [v,w] of i16x8vals) {
    testBinaryFunc(Int16x8(...v), Int16x8(...w), Int16x8.mul, muli);
  }
}

function testInt16x8or() {
  function ori(a, b) {
    return (a | b) << 16 >> 16;
  }

  for (var [v,w] of i16x8vals) {
    testBinaryFunc(Int16x8(...v), Int16x8(...w), Int16x8.or, ori);
  }
}

function testInt16x8sub() {
  function subi(a, b) {
    return (a - b) << 16 >> 16;
  }

  for (var [v,w] of i16x8vals) {
    testBinaryFunc(Int16x8(...v), Int16x8(...w), Int16x8.sub, subi);
  }
}

function testInt16x8xor() {
  function xori(a, b) {
    return (a ^ b) << 16 >> 16;
  }

  for (var [v,w] of i16x8vals) {
    testBinaryFunc(Int16x8(...v), Int16x8(...w), Int16x8.xor, xori);
  }
}

function testInt32x4add() {
  function addi(a, b) {
    return (a + b) | 0;
  }

  var valsExp = [
    [[1, 2, 3, 4], [10, 20, 30, 40]],
    [[INT32_MAX, INT32_MIN, INT32_MAX, INT32_MIN], [1, -1, 0, 0]]
  ];

  for (var [v,w] of valsExp) {
    testBinaryFunc(Int32x4(...v), Int32x4(...w), Int32x4.add, addi);
  }
}

function testInt32x4and() {
  function andi(a, b) {
    return (a & b) | 0;
  }

  var valsExp = [
    [[1, 2, 3, 4], [10, 20, 30, 40]],
    [[INT32_MAX, INT32_MIN, INT32_MAX, INT32_MIN], [INT32_MIN, INT32_MAX, INT32_MAX, INT32_MIN]]
  ];

  for (var [v,w] of valsExp) {
    testBinaryFunc(Int32x4(...v), Int32x4(...w), Int32x4.and, andi);
  }
}

function testInt32x4mul() {
  function muli(x, y) {
    return (x * y) | 0;
  }

  var valsExp = [
    [[1, 2, 3, 4], [10, 20, 30, 40]],
    [[INT32_MAX, INT32_MIN, INT32_MAX, INT32_MIN], [-1, -1, INT32_MIN, INT32_MIN]]
  ];

  for (var [v,w] of valsExp) {
    testBinaryFunc(Int32x4(...v), Int32x4(...w), Int32x4.mul, muli);
  }
}

function testInt32x4or() {
  function ori(a, b) {
    return (a | b) | 0;
  }

  var valsExp = [
    [[1, 2, 3, 4], [10, 20, 30, 40]],
    [[INT32_MAX, INT32_MIN, INT32_MAX, INT32_MIN], [INT32_MIN, INT32_MAX, INT32_MAX, INT32_MIN]]
  ];

  for (var [v,w] of valsExp) {
    testBinaryFunc(Int32x4(...v), Int32x4(...w), Int32x4.or, ori);
  }
}

function testInt32x4sub() {
  function subi(a, b) {
    return (a - b) | 0;
  }
  var valsExp = [
    [[10, 20, 30, 40], [1, 2, 3, 4]],
    [[INT32_MAX, INT32_MIN, INT32_MAX, INT32_MIN], [-1, 1, INT32_MAX, INT32_MIN]]
  ];

  for (var [v,w] of valsExp) {
    testBinaryFunc(Int32x4(...v), Int32x4(...w), Int32x4.sub, subi);
  }
}

function testInt32x4xor() {
  function xori(a, b) {
    return (a ^ b) | 0;
  }

  var valsExp = [
    [[1, 2, 3, 4], [10, 20, 30, 40]],
    [[INT32_MAX, INT32_MIN, INT32_MAX, INT32_MIN], [INT32_MIN, INT32_MAX, INT32_MAX, INT32_MIN]]
  ];

  for (var [v,w] of valsExp) {
    testBinaryFunc(Int32x4(...v), Int32x4(...w), Int32x4.xor, xori);
  }
}


function test() {
  testFloat32x4add();
  testFloat32x4and();
  testFloat32x4div();
  testFloat32x4mul();
  testFloat32x4or();
  testFloat32x4sub();
  testFloat32x4xor();

  testInt8x16add();
  testInt8x16and();
  testInt8x16mul();
  testInt8x16or();
  testInt8x16sub();
  testInt8x16xor();

  testInt16x8add();
  testInt16x8and();
  testInt16x8mul();
  testInt16x8or();
  testInt16x8sub();
  testInt16x8xor();

  testInt32x4add();
  testInt32x4and();
  testInt32x4mul();
  testInt32x4or();
  testInt32x4sub();
  testInt32x4xor();

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

test();