ChakraCore/test/Array/memset_invariant.js

//-------------------------------------------------------------------------------------------------------
// Copyright (C) Microsoft. All rights reserved.
// Licensed under the MIT license. See LICENSE.txt file in the project root for full license information.
//-------------------------------------------------------------------------------------------------------

function* makeValueGen(a, b) {
  // return a for profiling
  yield a;
  // return b to bailout
  yield b;
  // return b again to compare with non jit function
  yield b;
}

function* makeStartGen(a, b) {
  yield 0; // for interpreter
  yield 32; // for jitted version
  yield 32; // for jitted version
}

function makeTest(name, config) {
  const f1 = `function ${name}(arr) {
    for(var i = -5; i < 15; ++i) {arr[i] = ${config.v1};}
    return arr;
  }`;
  const f2 = customName => `function ${customName}P(arr, v) {
    for(var i = 1; i < 8; ++i) {arr[i] = v;}
    return arr;
  }`;
  const f3 = `function ${name}V(arr) {
    const v = ${config.v1};
    for(var i = -2; i < 17; ++i) {arr[i] = v;}
    return arr;
  }`;
  const f4 = customName => `function ${customName}Z(arr, start) {
    const v = ${config.v1};
    for(var i = start; i < 5; ++i) {arr[i] = v;}
    return arr;
  }`;

  const extraTests = (config.wrongTypes || []).map((wrongType, i) => {
    const difValue = {f: f2(`${name}W${i}`), compare: f2(`${name}WC${i}`)};
    const genValue = makeValueGen(config.v1, wrongType);
    Reflect.defineProperty(difValue, "v", {
      get: () => genValue.next().value
    });
    return difValue;
  });

  const negativeLengthTest = {f: f4(name), compare: f4(`${name}C`), newForCompare: true};
  const genIndex = makeStartGen();
  Reflect.defineProperty(negativeLengthTest, "v", {
    get: () => genIndex.next().value
  });

  const tests = [
    {f: f1},
    {f: f2(name), v: config.v2 !== undefined ? config.v2 : config.v1},
    {f: f3},
    negativeLengthTest
  ].concat(extraTests);

  const convertTest = function(fnText) {
    var fn;
    eval(`fn = ${fnText}`);
    return fn;
  };
  for(const t of tests) {
    t.f = convertTest(t.f);
    t.compare = t.compare && convertTest(t.compare);
  }
  return tests;
}

const allTypes = [0, 1.5, undefined, null, 9223372036854775807, "string", {a: null, b: "b"}];
const tests = [
  {name: "memsetUndefined", v1: undefined, wrongTypes: allTypes},
  {name: "memsetNull", v1: null, wrongTypes: allTypes},
  {name: "memsetFloat", v1: 3.14, v2: -87.684, wrongTypes: allTypes},
  {name: "memsetNumber", v1: 9223372036854775807, v2: -987654987654987, wrongTypes: allTypes},
  {name: "memsetBoolean", v1: true, v2: false, wrongTypes: allTypes},
  {name: "memsetString", v1: "\"thatString\"", v2: "`A template string`", wrongTypes: allTypes},
  {name: "memsetObject", v1: "{test: 1}", v2: [1, 2, 3], wrongTypes: allTypes},
];

const types = "Int8Array Uint8Array Int16Array Uint16Array Int32Array Uint32Array Float32Array Float64Array Array".split(" ");
const global = this;

let passed = true;
for(const test of tests) {
  for(const t of types) {
    const fns = makeTest(`${test.name}${t}`, test);
    for(const detail of fns) {
      const fn = detail.f;
      let a1 = fn(new global[t](10), detail.v);
      const a2 = fn(new global[t](10), detail.v);
      if(detail.compare) {
        // the optimized version ran with a different value. Run again with a clean function to compare=
        a1 = detail.compare(detail.newForCompare ? new global[t](10) : a1, detail.v);
      }
      if(a1.length !== a2.length) {
        passed = false;
        print(`${fn.name} (${t}) didn't return arrays with same length`);
        continue;
      }
      for(let i = 0; i < a1.length; ++i) {
        if(a1[i] !== a2[i] && !(isNaN(a1[i]) && isNaN(a2[i]))) {
          passed = false;
          print(`${fn.name} (${t}): a1[${i}](${a1[i]}) != a2[${i}](${a2[i]})`);
          break;
        }
      }
    }
  }
}

function memsetSymbol() {const s = Symbol(); const arr = new Array(10); for(let i = 0; i < 10; ++i) {arr[i] = s;} return arr;}
function memsetSymbolV(v) {const arr = new Array(10); for(let i = 0; i < 10; ++i) {arr[i] = v;} return arr;}
function checkSymbols() {
  const s = Symbol();
  // Since symbol are unique, and we want to compare the result, we have to pass the same symbol everytime
  const a1 = memsetSymbolV(s);
  const a2 = memsetSymbolV(s);
  for(let i = 0; i < a1.length; ++i) {
    if(a1[i] !== a2[i]) {
      passed = false;
      // need explicit toString() for Symbol
      print(`memsetSymbolV: a1[${i}](${a1[i].toString()}) != a2[${i}](${a2 && a2[i].toString() || ""})`);
      break;
    }
  }

  memsetSymbol();
  const symbolArray = memsetSymbol();
  for(let i = 0; i < symbolArray.length; ++i) {
    if(typeof symbolArray[i] !== typeof s) {
      passed = false;
      print(`memsetSymbol: symbolArray[${i}] is not a Symbol`);
      break;
    }
  }
}
checkSymbols();

print(passed ? "PASSED" : "FAILED");