222 lines
6.2 KiB
JavaScript
222 lines
6.2 KiB
JavaScript
// META: title=Validate WebNN test helpers
|
|
// META: script=resources/utils.js
|
|
|
|
// This doesn't validate the WebNN API itself, it just verifies behavior of
|
|
// non-trivial helper functions.
|
|
|
|
'use strict';
|
|
|
|
// Largest integer uniquely representable as a float32.
|
|
const MAX_FLOAT32_INTEGER = 2 ** 24;
|
|
|
|
test(t => {
|
|
const dataType = 'float32';
|
|
[[0.0, 0.0, 0n],
|
|
[0.0, 1e-46, 0n],
|
|
[0.0, 1e-36, 61482021n],
|
|
[1.0, 1.0, 0n],
|
|
[1.0, -1.0, 2130706432n],
|
|
[1.0, 2.0, 8388608n],
|
|
[1.000001, 1.000002, 9n],
|
|
[1.0000001, 1.0000002, 1n],
|
|
[-1.000001, 1.000002, 2130706457n],
|
|
[-1.0000001, 1.0000002, 2130706435n],
|
|
[0.0, 1.401298464324817e-45, 1n],
|
|
[99.28312683105469, 39.03501892089844, 11169050n],
|
|
[MAX_FLOAT32_INTEGER - 1, MAX_FLOAT32_INTEGER, 1n],
|
|
].forEach(([a, b, expected]) => {
|
|
assert_equals(
|
|
ulpDistance(a, b, dataType), expected,
|
|
`ULP distance between ${a} and ${b}`);
|
|
assert_equals(
|
|
ulpDistance(b, a, dataType), expected,
|
|
`ULP distance between ${b} and ${a} (commutative)`);
|
|
assert_equals(
|
|
ulpDistance(-a, -b, dataType), expected,
|
|
`ULP distance between ${- a} and ${- b} (negated)`);
|
|
});
|
|
}, 'ULP Distance - float32');
|
|
|
|
// TODO: Add test cases for 'float16' data type.
|
|
|
|
test(t => {
|
|
const dataType = 'int64';
|
|
[[0n, 0n, 0n],
|
|
[1n, 0n, 1n],
|
|
[1n, 2n, 1n],
|
|
[10n, 11n, 1n],
|
|
[10n, 20n, 10n],
|
|
[100000001n, 100000002n, 1n],
|
|
[0x7FFFFFFFFFFFFFFEn, 0x7FFFFFFFFFFFFFFFn, 1n],
|
|
[-0x7FFFFFFFFFFFFFFFn, 0x7FFFFFFFFFFFFFFFn, 0xFFFFFFFFFFFFFFFEn],
|
|
].forEach(([a, b, expected]) => {
|
|
assert_equals(
|
|
ulpDistance(a, b, dataType), expected,
|
|
`ULP distance between ${a} and ${b}`);
|
|
assert_equals(
|
|
ulpDistance(b, a, dataType), expected,
|
|
`ULP distance between ${b} and ${a} (commutative)`);
|
|
assert_equals(
|
|
ulpDistance(-a, -b, dataType), expected,
|
|
`ULP distance between ${- a} and ${- b} (negated)`);
|
|
});
|
|
assert_equals(
|
|
ulpDistance(-0x8000000000000000n, 0x7FFFFFFFFFFFFFFFn, dataType),
|
|
0xFFFFFFFFFFFFFFFFn, 'ULP distance between min and max int64');
|
|
}, 'ULP Distance - int64');
|
|
|
|
test(t => {
|
|
const dataType = 'uint64';
|
|
[[0n, 0n, 0n],
|
|
[1n, 0n, 1n],
|
|
[1n, 2n, 1n],
|
|
[10n, 11n, 1n],
|
|
[10n, 20n, 10n],
|
|
[100000001n, 100000002, 1n],
|
|
[0xFFFFFFFFFFFFFFFEn, 0xFFFFFFFFFFFFFFFFn, 1n],
|
|
[0n, 0xFFFFFFFFFFFFFFFFn, 0xFFFFFFFFFFFFFFFFn],
|
|
].forEach(([a, b, expected]) => {
|
|
assert_equals(
|
|
ulpDistance(a, b, dataType), expected,
|
|
`ULP distance between ${a} and ${b}`);
|
|
assert_equals(
|
|
ulpDistance(b, a, dataType), expected,
|
|
`ULP distance between ${b} and ${a} (commutative)`);
|
|
});
|
|
}, 'ULP Distance - uint64');
|
|
|
|
test(t => {
|
|
const dataType = 'int32';
|
|
[[0, 0, 0],
|
|
[1, 0, 1],
|
|
[1, 2, 1],
|
|
[10, 11, 1],
|
|
[10, 20, 10],
|
|
[100000001, 100000002, 1],
|
|
[0x7FFFFFFE, 0x7FFFFFFF, 1],
|
|
[-0x7FFFFFFF, 0x7FFFFFFF, 0xFFFFFFFE],
|
|
].forEach(([a, b, expected]) => {
|
|
assert_equals(
|
|
ulpDistance(a, b, dataType), expected,
|
|
`ULP distance between ${a} and ${b}`);
|
|
assert_equals(
|
|
ulpDistance(b, a, dataType), expected,
|
|
`ULP distance between ${b} and ${a} (commutative)`);
|
|
assert_equals(
|
|
ulpDistance(-a, -b, dataType), expected,
|
|
`ULP distance between ${- a} and ${- b} (negated)`);
|
|
});
|
|
assert_equals(
|
|
ulpDistance(-0x80000000, 0x7FFFFFFF, dataType), 0xFFFFFFFF,
|
|
'ULP distance between min and max int32');
|
|
}, 'ULP Distance - int32');
|
|
|
|
test(t => {
|
|
const dataType = 'uint32';
|
|
[[0, 0, 0],
|
|
[1, 0, 1],
|
|
[1, 2, 1],
|
|
[10, 11, 1],
|
|
[10, 20, 10],
|
|
[100000001, 100000002, 1],
|
|
[0xFFFFFFFE, 0xFFFFFFFF, 1],
|
|
[0, 0xFFFFFFFF, 0xFFFFFFFF],
|
|
].forEach(([a, b, expected]) => {
|
|
assert_equals(
|
|
ulpDistance(a, b, dataType), expected,
|
|
`ULP distance between ${a} and ${b}`);
|
|
assert_equals(
|
|
ulpDistance(b, a, dataType), expected,
|
|
`ULP distance between ${b} and ${a} (commutative)`);
|
|
});
|
|
}, 'ULP Distance - uint32');
|
|
|
|
test(t => {
|
|
const dataType = 'int8';
|
|
[[0, 0, 0],
|
|
[1, 0, 1],
|
|
[1, 2, 1],
|
|
[10, 11, 1],
|
|
[10, 20, 10],
|
|
[101, 102, 1],
|
|
[0x7E, 0x7F, 1],
|
|
[-0x7F, 0x7F, 0xFE],
|
|
].forEach(([a, b, expected]) => {
|
|
assert_equals(
|
|
ulpDistance(a, b, dataType), expected,
|
|
`ULP distance between ${a} and ${b}`);
|
|
assert_equals(
|
|
ulpDistance(b, a, dataType), expected,
|
|
`ULP distance between ${b} and ${a} (commutative)`);
|
|
assert_equals(
|
|
ulpDistance(-a, -b, dataType), expected,
|
|
`ULP distance between ${- a} and ${- b} (negated)`);
|
|
});
|
|
assert_equals(
|
|
ulpDistance(-0x80, 0x7F, dataType), 0xFF,
|
|
'ULP distance between min and max int8');
|
|
}, 'ULP Distance - int8');
|
|
|
|
test(t => {
|
|
const dataType = 'uint8';
|
|
[[0, 0, 0],
|
|
[1, 0, 1],
|
|
[1, 2, 1],
|
|
[10, 11, 1],
|
|
[10, 20, 10],
|
|
[101, 102, 1],
|
|
[0xFE, 0xFF, 1],
|
|
[0, 0xFF, 0xFF],
|
|
].forEach(([a, b, expected]) => {
|
|
assert_equals(
|
|
ulpDistance(a, b, dataType), expected,
|
|
`ULP distance between ${a} and ${b}`);
|
|
assert_equals(
|
|
ulpDistance(b, a, dataType), expected,
|
|
`ULP distance between ${b} and ${a} (commutative)`);
|
|
});
|
|
}, 'ULP Distance - uint8');
|
|
|
|
test(t => {
|
|
const dataType = 'int4';
|
|
[[0, 0, 0],
|
|
[1, 0, 1],
|
|
[1, 2, 1],
|
|
[10, 11, 1],
|
|
[1, 10, 9],
|
|
[6, 7, 1],
|
|
[-7, 7, 14],
|
|
].forEach(([a, b, expected]) => {
|
|
assert_equals(
|
|
ulpDistance(a, b, dataType), expected,
|
|
`ULP distance between ${a} and ${b}`);
|
|
assert_equals(
|
|
ulpDistance(b, a, dataType), expected,
|
|
`ULP distance between ${b} and ${a} (commutative)`);
|
|
assert_equals(
|
|
ulpDistance(-a, -b, dataType), expected,
|
|
`ULP distance between ${- a} and ${- b} (negated)`);
|
|
});
|
|
assert_equals(
|
|
ulpDistance(-0x8, 0x7, dataType), 0xF,
|
|
'ULP distance between min and max int4');
|
|
}, 'ULP Distance - int4');
|
|
|
|
test(t => {
|
|
const dataType = 'uint4';
|
|
[[0, 0, 0],
|
|
[1, 0, 1],
|
|
[1, 2, 1],
|
|
[10, 11, 1],
|
|
[1, 10, 9],
|
|
[0xE, 0xF, 1],
|
|
[0, 0xF, 0xF],
|
|
].forEach(([a, b, expected]) => {
|
|
assert_equals(
|
|
ulpDistance(a, b, dataType), expected,
|
|
`ULP distance between ${a} and ${b}`);
|
|
assert_equals(
|
|
ulpDistance(b, a, dataType), expected,
|
|
`ULP distance between ${b} and ${a} (commutative)`);
|
|
});
|
|
}, 'ULP Distance - uint4');
|