Source code
Revision control
Copy as Markdown
Other Tools
Test Info:
- This WPT test may be referenced by the following Test IDs:
- /webnn/helper-validation.window.html - WPT Dashboard Interop Dashboard
// 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');