onnxruntime/js/node/test/unittests/lib/tensor.ts

// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.

import * as assert from 'assert';
// tensor with type information
import { Tensor } from 'onnxruntime-common';

import { createTestData, NUMERIC_TYPE_MAP } from '../../test-utils';

// tensor with no type information, used for testing type check
const TensorAny = Tensor as any;

function testAllTensortypes(
  title: string,
  length: number,
  funcNumerictypes: (passtypeParam: boolean, type: Tensor.Type, data: Tensor.DataType) => void,
  funcStringtype?: (passtypeParam: boolean, data: string[]) => void,
): void {
  NUMERIC_TYPE_MAP.forEach((ctor, type) => {
    it(`${title} - (${type}, ${ctor.name})`, () => {
      funcNumerictypes(true, type, createTestData(type, length));
    });
    if (type !== 'bool') {
      it(`${title} - (${ctor.name})`, () => {
        funcNumerictypes(false, type, createTestData(type, length));
      });
    }
  });
  if (!funcStringtype) {
    it(`${title} - (string, ${Array.name})`, () => {
      funcNumerictypes(true, 'string', createTestData('string', length));
    });
    it(`${title} - (${Array.name})`, () => {
      funcNumerictypes(false, 'string', createTestData('string', length));
    });
  } else {
    it(`${title} - (string, string[])`, () => {
      funcStringtype(true, createTestData('string', length) as string[]);
    });
    it(`${title} - (string[])`, () => {
      funcStringtype(false, createTestData('string', length) as string[]);
    });
  }
}

describe('UnitTests - tensor', () => {
  testAllTensortypes('check data and type', 100, (passtypeParam, type, data) => {
    // numeric and string tensors
    const tensor0 = passtypeParam ? new Tensor(type, data) : new Tensor(data);
    assert.strictEqual(tensor0.data, data, 'tensor.data and data should be the same object.');
    assert.strictEqual(tensor0.type, type, 'tensor.type and type should be equal.');
  });

  testAllTensortypes('check dims (omitted)', 200, (passtypeParam, type, data) => {
    // numeric and string tensors
    const tensor0 = passtypeParam ? new Tensor(type, data) : new Tensor(data);
    assert.deepStrictEqual(
      tensor0.dims,
      [200],
      'tensor.dims should be a number array with exactly 1 item, with value of the array length.',
    );
  });

  testAllTensortypes('check dims (specified)', 60, (passtypeParam, type, data) => {
    // numeric and string tensors
    const tensor0 = passtypeParam ? new Tensor(type, data, [3, 4, 5]) : new Tensor(data, [3, 4, 5]);
    assert.deepStrictEqual(tensor0.dims, [3, 4, 5], 'tensor.dims should be a number array with the given 3 items.');
  });

  testAllTensortypes('BAD CALL - invalid dims type', 100, (passtypeParam, type, data) => {
    // numeric and string tensors
    assert.throws(
      () => {
        const badDims = {};
        passtypeParam ? new TensorAny(type, data, badDims) : new TensorAny(data, badDims);
      },
      { name: 'TypeError', message: /must be a number array/ },
    );
  });
  testAllTensortypes('BAD CALL - invalid dims element type', 100, (passtypeParam, type, data) => {
    // numeric and string tensors
    assert.throws(
      () => {
        const badDims = [1, 2, ''];
        passtypeParam ? new TensorAny(type, data, badDims) : new TensorAny(data, badDims);
      },
      { name: 'TypeError', message: /must be an integer/ },
    );
  });
  testAllTensortypes('BAD CALL - invalid dims number type (negative)', 100, (passtypeParam, type, data) => {
    // numeric and string tensors
    assert.throws(
      () => {
        const badDims = [1, 2, -1];
        passtypeParam ? new TensorAny(type, data, badDims) : new TensorAny(data, badDims);
      },
      { name: 'RangeError', message: /must be a non-negative integer/ },
    );
  });
  testAllTensortypes('BAD CALL - invalid dims number type (non-integer)', 100, (passtypeParam, type, data) => {
    // numeric and string tensors
    assert.throws(
      () => {
        const badDims = [1, 2, 1.5];
        passtypeParam ? new TensorAny(type, data, badDims) : new TensorAny(data, badDims);
      },
      { name: 'TypeError', message: /must be an integer/ },
    );
  });

  testAllTensortypes('BAD CALL - length and dims does not match', 100, (passtypeParam, type, data) => {
    // numeric and string tensors
    assert.throws(
      () => {
        const badDims = [10, 8];
        passtypeParam ? new TensorAny(type, data, badDims) : new TensorAny(data, badDims);
      },
      { name: 'Error', message: /does not match data length/ },
    );
  });
});