webnn/validation_tests/constant.https.any.js

// META: title=validation tests for WebNN API constant interface
// META: global=window,worker
// META: variant=?cpu
// META: variant=?gpu
// META: variant=?npu
// META: script=../resources/utils_validation.js

'use strict';

const tests = [
  // Tests for constant(descriptor, buffer)
  {
    name:
        '[constant] Test building a 0-D scalar constant with empty dimensions',
    descriptor: {dataType: 'float32', shape: []},
    buffer: {type: Float32Array, byteLength: 1 * 4},
    output: {dataType: 'float32', shape: []}
  },
  {
    name: '[constant] Test building a constant with float32 data type',
    descriptor: {dataType: 'float32', shape: [2, 3]},
    buffer: {type: Float32Array, byteLength: 6 * 4},
    output: {dataType: 'float32', shape: [2, 3]}
  },
  {
    name:
        '[constant] Throw if byte length of float32 buffer doesn\'t match the given dimensions',
    descriptor: {dataType: 'float32', shape: [2, 3]},
    buffer: {
      type: Float32Array,
      byteLength: 6 * 4 - 4  // The buffer's byte length is less than the
                             // one by given dimensions
    }
  },
  {
    name: '[constant] Test building a constant with float16 data type',
    descriptor: {dataType: 'float16', shape: [2, 3]},
    buffer: {type: Float16Array, byteLength: 6 * 2},
    output: {dataType: 'float16', shape: [2, 3]}
  },
  {
    name:
        '[constant] Throw if byte length of float16 buffer doesn\'t match the given dimensions',
    descriptor: {dataType: 'float16', shape: [2, 3]},
    buffer: {
      type: Float16Array,
      byteLength: 6 * 2 - 2  // The buffer's byte length is less than the
                             // one by given dimensions
    }
  },
  {
    name:
        '[constant] Throw if using Float32Array buffer for float16 operand data type',
    descriptor: {dataType: 'float16', shape: [2, 3]},
    buffer: {
      type: Float32Array,
      byteLength: 6 * 4,
    },
    viewTestOnly: true
  },
  {
    name:
        '[constant] Throw if using Int16Array buffer for float16 operand data type',
    descriptor: {dataType: 'float16', shape: [2, 3]},
    buffer: {
      type: Int16Array,
      byteLength: 6 * 2,
    },
    viewTestOnly: true
  },

  // TODO(crbug.com/399459942): remove below two Uint16Array buffer tests for
  // float16 data type when implementation removes it.
  {
    name:
        '[constant] Test building a constant with float16 data type using Uint16Array buffer',
    descriptor: {dataType: 'float16', shape: [2, 3]},
    buffer: {type: Uint16Array, byteLength: 6 * 2},
    output: {dataType: 'float16', shape: [2, 3]}
  },
  {
    name:
        '[constant] Throw if byte length of float16 buffer (using Uint16Array buffer) doesn\'t match the given dimensions',
    descriptor: {dataType: 'float16', shape: [2, 3]},
    buffer: {
      type: Uint16Array,
      byteLength: 6 * 2 - 2  // The buffer's byte length is less than the
                             // one by given dimensions
    }
  },
  {
    name: '[constant] Test building a constant with int32 data type',
    descriptor: {dataType: 'int32', shape: [2, 3]},
    buffer: {type: Int32Array, byteLength: 6 * 4},
    output: {dataType: 'int32', shape: [2, 3]}
  },
  {
    name:
        '[constant] Throw if byte length of int32 buffer doesn\'t match the given dimensions',
    descriptor: {dataType: 'int32', shape: [2, 3]},
    buffer: {
      type: Int32Array,
      byteLength: 6 * 4 + 4  // The buffer's byte length is greater than the
                             // one by given dimensions
    }
  },
  {
    name: '[constant] Test building a constant with uint32 data type',
    descriptor: {dataType: 'uint32', shape: [2, 3]},
    buffer: {type: Uint32Array, byteLength: 6 * 4},
    output: {dataType: 'uint32', shape: [2, 3]}
  },
  {
    name:
        '[constant] Throw if byte length of uint32 buffer doesn\'t match the given dimensions',
    descriptor: {dataType: 'uint32', shape: [2, 3]},
    buffer: {type: Uint32Array, byteLength: 6 * 4 + 4}
  },
  {
    name: '[constant] Test building a constant with int64 data type',
    descriptor: {dataType: 'int64', shape: [2, 3]},
    buffer: {type: BigInt64Array, byteLength: 6 * 8},
    output: {dataType: 'int64', shape: [2, 3]}
  },
  {
    name:
        '[constant] Throw if byte length of int64 buffer doesn\'t match the given dimensions',
    descriptor: {dataType: 'int64', shape: [2, 3]},
    buffer: {type: BigInt64Array, byteLength: 6 * 8 + 8}
  },
  {
    name: '[constant] Test building a constant with uint64 data type',
    descriptor: {dataType: 'uint64', shape: [2, 3]},
    buffer: {type: BigUint64Array, byteLength: 6 * 8},
    output: {dataType: 'uint64', shape: [2, 3]}
  },
  {
    name:
        '[constant] Throw if byte length of uint64 buffer doesn\'t match the given dimensions',
    descriptor: {dataType: 'uint64', shape: [2, 3]},
    buffer: {type: BigUint64Array, byteLength: 6 * 8 + 8}
  },
  {
    name: '[constant] Test building a constant with int8 data type',
    descriptor: {dataType: 'int8', shape: [2, 3]},
    buffer: {type: Int8Array, byteLength: 6 * 1},
    output: {dataType: 'int8', shape: [2, 3]}
  },
  {
    name:
        '[constant] Throw if byte length of int8 buffer doesn\'t match the given dimensions',
    descriptor: {dataType: 'int8', shape: [2, 3]},
    buffer: {type: Int8Array, byteLength: 6 * 4 - 4}
  },
  {
    name: '[constant] Test building a constant with uint8 data type',
    descriptor: {dataType: 'uint8', shape: [2, 3]},
    buffer: {type: Uint8Array, byteLength: 6 * 1},
    output: {dataType: 'uint8', shape: [2, 3]}
  },
  {
    name:
        '[constant] Throw if byte length of uint8 buffer doesn\'t match the given dimensions',
    descriptor: {dataType: 'uint8', shape: [2, 3]},
    buffer: {type: Uint8Array, byteLength: 6 * 4 - 4}
  },
  {
    name: '[constant] Throw if a dimension is 0',
    descriptor: {dataType: 'float32', shape: [2, 0]},
    buffer: {type: Float32Array, byteLength: 2 * 4}
  },
  {
    name:
        '[constant] Throw if using Int32Array buffer for float32 operand data type',
    descriptor: {dataType: 'float32', shape: [2, 3]},
    buffer: {type: Int32Array, byteLength: 6 * 4},
    viewTestOnly: true
  },
  {
    name:
        '[constant] Throw if the operand data type isn\'t of type MLOperandDataType',
    descriptor: {dataType: 'int16', shape: [2, 3]},
    buffer: {type: Int16Array, byteLength: 6 * 2}
  }
];

tests.forEach(
    test => promise_test(async t => {
      const builder = new MLGraphBuilder(context);
      const buffer = new ArrayBuffer(test.buffer.byteLength);
      const bufferView = new test.buffer.type(buffer);

      if (test.viewTestOnly === undefined || test.viewTestOnly === false) {
        // Test building constant from ArrayBuffer.
        if (test.output) {
          const constantOperand = builder.constant(test.descriptor, buffer);
          assert_equals(constantOperand.dataType, test.output.dataType);
          assert_array_equals(constantOperand.shape, test.output.shape);
        } else {
          assert_throws_js(
              TypeError, () => builder.constant(test.descriptor, buffer));
        }
        if ('SharedArrayBuffer' in globalThis) {
          // Test building constant from SharedArrayBuffer.
          const sharedBuffer = new SharedArrayBuffer(test.buffer.byteLength);
          if (test.output) {
            const constantOperand =
                builder.constant(test.descriptor, sharedBuffer);
            assert_equals(constantOperand.dataType, test.output.dataType);
            assert_array_equals(constantOperand.shape, test.output.shape);
          } else {
            assert_throws_js(
                TypeError,
                () => builder.constant(test.descriptor, sharedBuffer));
          }
        }
      }

      // Test building constant from ArrayBufferView.
      if (test.output) {
        const constantOperand = builder.constant(test.descriptor, bufferView);
        assert_equals(constantOperand.dataType, test.output.dataType);
        assert_array_equals(constantOperand.shape, test.output.shape);
      } else {
        assert_throws_js(
            TypeError, () => builder.constant(test.descriptor, bufferView));
      }
      if ('SharedArrayBuffer' in globalThis) {
        // Test building constant from shared ArrayBufferView.
        const sharedBuffer = new SharedArrayBuffer(test.buffer.byteLength);
        const sharedBufferView = new test.buffer.type(sharedBuffer);
        if (test.output) {
          const constantOperand =
              builder.constant(test.descriptor, sharedBufferView);
          assert_equals(constantOperand.dataType, test.output.dataType);
          assert_array_equals(constantOperand.shape, test.output.shape);
        } else {
          assert_throws_js(
              TypeError,
              () => builder.constant(test.descriptor, sharedBufferView));
        }
      }
    }, test.name));