// file: testTypedArray.js
// Copyright (C) 2015 André Bargull. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.

/**
 * Array containing every typed array constructor.
 */
var typedArrayConstructors = [
  Float64Array,
  Float32Array,
  Int32Array,
  Int16Array,
  Int8Array,
  Uint32Array,
  Uint16Array,
  Uint8Array,
  Uint8ClampedArray
];

/**
 * The %TypedArray% intrinsic constructor function.
 */
var TypedArray = Object.getPrototypeOf(Int8Array);

/**
 * Callback for testing a typed array constructor.
 *
 * @callback typedArrayConstructorCallback
 * @param {Function} Constructor the constructor object to test with.
 */

/**
 * Calls the provided function for every typed array constructor.
 *
 * @param {typedArrayConstructorCallback} f - the function to call for each typed array constructor.
 * @param {Array} selected - An optional Array with filtered typed arrays
 */
function testWithTypedArrayConstructors(f, selected) {
  var constructors = selected || typedArrayConstructors;
  for (var i = 0; i < constructors.length; ++i) {
    var constructor = constructors[i];
    try {
      f(constructor);
    } catch (e) {
      e.message += " (Testing with " + constructor.name + ".)";
      throw e;
    }
  }
}

/**
 * Helper for conversion operations on TypedArrays, the expected values
 * properties are indexed in order to match the respective value for each
 * TypedArray constructor
 * @param  {Function} fn - the function to call for each constructor and value.
 *                         will be called with the constructor, value, expected
 *                         value, and a initial value that can be used to avoid
 *                         a false positive with an equivalent expected value.
 */
function testTypedArrayConversions(byteConversionValues, fn) {
  var values = byteConversionValues.values;
  var expected = byteConversionValues.expected;

  testWithTypedArrayConstructors(function(TA) {
    var name = TA.name.slice(0, -5);

    return values.forEach(function(value, index) {
      var exp = expected[name][index];
      var initial = 0;
      if (exp === 0) {
        initial = 1;
      }
      fn(TA, value, exp, initial);
    });
  });
}

// file: testAtomics.js
// Copyright (C) 2017 Mozilla Corporation. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.

/**
 * Calls the provided function for a each bad index that should throw a
 * RangeError when passed to an Atomics method on a SAB-backed view where
 * index 125 is out of range.
 *
 * @param f - the function to call for each bad index.
 */
function testWithAtomicsOutOfBoundsIndices(f) {
    var bad_indices = [
        (view) => -1,
        (view) => view.length,
        (view) => view.length*2,
        (view) => Number.POSITIVE_INFINITY,
        (view) => Number.NEGATIVE_INFINITY,
        (view) => ({ valueOf: () => 125 }),
        (view) => ({ toString: () => '125', valueOf: false }) // non-callable valueOf triggers invocation of toString
    ];

    for (let IdxGen of bad_indices) {
        try {
            f(IdxGen);
        } catch (e) {
            e.message += " (Testing with index gen " + IdxGen + ".)";
            throw e;
        }
    }
}

/**
 * Calls the provided function for each good index that should not throw when
 * passed to an Atomics method on a SAB-backed view.
 *
 * The view must have length greater than zero.
 *
 * @param f - the function to call for each good index.
 */
function testWithAtomicsInBoundsIndices(f) {
    // Most of these are eventually coerced to +0 by ToIndex.
    var good_indices = [
        (view) => 0/-1,
        (view) => '-0',
        (view) => undefined,
        (view) => NaN,
        (view) => 0.5,
        (view) => '0.5',
        (view) => -0.9,
        (view) => ({ password: "qumquat" }),
        (view) => view.length - 1,
        (view) => ({ valueOf: () => 0 }),
        (view) => ({ toString: () => '0', valueOf: false }) // non-callable valueOf triggers invocation of toString
    ];

    for (let IdxGen of good_indices) {
        try {
            f(IdxGen);
        } catch (e) {
            e.message += " (Testing with index gen " + IdxGen + ".)";
            throw e;
        }
    }
}

/**
 * Calls the provided function for each value that should throw a TypeError
 * when passed to an Atomics method as a view.
 *
 * @param f - the function to call for each non-view value.
 */

function testWithAtomicsNonViewValues(f) {
    var values = [
        null,
        undefined,
        true,
        false,
        new Boolean(true),
        10,
        3.14,
        new Number(4),
        "Hi there",
        new Date,
        /a*utomaton/g,
        { password: "qumquat" },
        new DataView(new ArrayBuffer(10)),
        new ArrayBuffer(128),
        new SharedArrayBuffer(128),
        new Error("Ouch"),
        [1,1,2,3,5,8],
        ((x) => -x),
        new Map(),
        new Set(),
        new WeakMap(),
        new WeakSet(),
        Symbol("halleluja"),
        // TODO: Proxy?
        Object,
        Int32Array,
        Date,
        Math,
        Atomics
    ];

    for (let nonView of values) {
        try {
            f(nonView);
        } catch (e) {
            e.message += " (Testing with non-view value " + nonView + ".)";
            throw e;
        }
    }
}
