Function expectArraysPredicate

tfjs-core/src/test_util.ts:41–99

(
    actual: TensorLike, expected: TensorLike,
    predicate: (a: {}, b: {}) => boolean)

}

function expectArraysPredicate(
    actual: TensorLike, expected: TensorLike,
    predicate: (a: {}, b: {}) => boolean) {
  let checkClassType = true;
  if (isTypedArray(actual) || isTypedArray(expected)) {
    checkClassType = false;
  }
  if (isTypedArray(actual) && isTypedArray(expected)) {
    checkClassType = true;
  }
  if (checkClassType) {
    const aType = actual.constructor.name;
    const bType = expected.constructor.name;

    if (aType !== bType) {
      throw new Error(
          `Arrays are of different type. Actual: ${aType}. ` +
          `Expected: ${bType}`);
    }
  }

  if (Array.isArray(actual) && Array.isArray(expected)) {
    const actualShape = inferShape(actual);
    const expectedShape = inferShape(expected);
    if (!arraysEqual(actualShape, expectedShape)) {
      throw new Error(
          `Arrays have different shapes. ` +
          `Actual: [${actualShape}]. Expected: [${expectedShape}]`);
    }
  }

  const actualFlat =
      isTypedArray(actual) ? actual : flatten(actual as RecursiveArray<number>);
  const expectedFlat = isTypedArray(expected) ?
      expected :
      flatten(expected as RecursiveArray<number>);

  if (actualFlat.length !== expectedFlat.length) {
    throw new Error(
        `Arrays have different lengths actual: ${actualFlat.length} vs ` +
        `expected: ${expectedFlat.length}.\n` +
        `Actual:   ${actualFlat}.\n` +
        `Expected: ${expectedFlat}.`);
  }
  for (let i = 0; i < expectedFlat.length; ++i) {
    const a = actualFlat[i];
    const e = expectedFlat[i];

    if (!predicate(a, e)) {
      throw new Error(
          `Arrays differ: actual[${i}] = ${a}, expected[${i}] = ${e}.\n` +
          `Actual:   ${actualFlat}.\n` +
          `Expected: ${expectedFlat}.`);
    }
  }
  if (typeof expect !== 'undefined') {
    expect().nothing();
  }