corysanin/tubestation
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Bug 1962037 - test(webgpu): update CTS to c09e68cdaa4aded26b769443c743985a6cedd383 r=webgpu-reviewers,nical

Browse Source 
Differential Revision: https://phabricator.services.mozilla.com/D246414
This commit is contained in:
Erich Gubler
2025-04-28 20:34:55 +00:00
parent 38bc73cdb8
commit 746586f2d6
399 changed files with 8192 additions and 5497 deletions
Download Patch File Download Diff File Expand all files Collapse all files

23
dom/webgpu/tests/cts/checkout/docs/fp_primer.md
View File

@@ -258,8 +258,23 @@ digits of precision.
For the CTS it is often sufficient to calculate the true value using TypeScript,
since its native number format is higher precision (double-precision/f64), so
all f64, f32, and f16 values can be represented in it. Where this breaks down
will be discussed in the section on compile time vs runtime execution.
all f64, f32, and f16 values can be represented in it. Unfortunately, the
results of some operations cannot be exactly represent in double-precision. A
simple example here is subtracting a small magnitude number from a large
magnitude number.
Say we have `x - y` where `x = 1.0` and `y = 1.17e-38` (which is smallest
normal in f32)
In doing the subtraction, all the significant bits of `y` are lost. The result
in JS uses round-to-even, and we get `x - y = x` which is not the true value of
this operation
The CTS does best effort on these important edge cases to allow for all
acceptable results of these operations. Internally this boils down creating to
an interval bounding the true value. Where this breaks down will further be
discussed in the section on compile time vs runtime execution.
The true value is sometimes representable exactly as a floating point value, but
often is not.
@@ -899,6 +914,7 @@ shader being run.
|------------------------|---------------:|------------:|---------:|--------------:|-----------------------------:|
| Negative Infinity | -∞ | 0xff80 0000 | 1 | 1111 1111 | 0000 0000 0000 0000 0000 000 |
| Min Negative Normal | -3.40282346E38 | 0xff7f ffff | 1 | 1111 1110 | 1111 1111 1111 1111 1111 111 |
| Max Negative i32 | -2147483648 | 0xCF00 0000 | 1 | 1001 1110 | 0000 0000 0000 0000 0000 000 |
| Max Negative Normal | -1.1754943E−38 | 0x8080 0000 | 1 | 0000 0001 | 0000 0000 0000 0000 0000 000 |
| Min Negative Subnormal | -1.1754942E-38 | 0x807f ffff | 1 | 0000 0000 | 1111 1111 1111 1111 1111 111 |
| Max Negative Subnormal | -1.4012984E−45 | 0x8000 0001 | 1 | 0000 0000 | 0000 0000 0000 0000 0000 001 |
@@ -907,9 +923,12 @@ shader being run.
| Min Positive Subnormal | 1.4012984E−45 | 0x0000 0001 | 0 | 0000 0000 | 0000 0000 0000 0000 0000 001 |
| Max Positive Subnormal | 1.1754942E-38 | 0x007f ffff | 0 | 0000 0000 | 1111 1111 1111 1111 1111 111 |
| Min Positive Normal | 1.1754943E−38 | 0x0080 0000 | 0 | 0000 0001 | 0000 0000 0000 0000 0000 000 |
| Max Positive i32 | 2147483520 | 0x4efff fff | 0 | 1001 1101 | 1111 1111 1111 1111 1111 111 |
| Max Positive u32 | 4294967040 | 0x4f7f ffff | 0 | 1001 1110 | 1111 1111 1111 1111 1111 111 |
| Max Positive Normal | 3.40282346E38 | 0x7f7f ffff | 0 | 1111 1110 | 1111 1111 1111 1111 1111 111 |
| Negative Infinity | ∞ | 0x7f80 0000 | 0 | 1111 1111 | 0000 0000 0000 0000 0000 000 |
### Significant f16 Values
| Name | Decimal (~) | Hex | Sign Bit | Exponent Bits | Significand Bits |

2
dom/webgpu/tests/cts/checkout/src/common/framework/fixture.ts
View File

@@ -250,7 +250,7 @@ export class Fixture<S extends SubcaseBatchState = SubcaseBatchState> {
* Wraps an async function, passing it an `Error` object recording the original stack trace.
* The async work will be implicitly waited upon before reporting a test status.
*/
protected eventualAsyncExpectation<T>(fn: (niceStack: Error) => Promise<T>): void {
eventualAsyncExpectation<T>(fn: (niceStack: Error) => Promise<T>): void {
const promise = fn(new Error());
this.eventualExpectations.push(promise);
}

3
dom/webgpu/tests/cts/checkout/src/common/runtime/helper/test_worker.ts
View File

@@ -23,8 +23,7 @@ function unregisterAllServiceWorkers() {
// important, so we try our best (and don't worry about shutdown performance or disabling bfcache).
// (We could try 'visibilitychange', but since it can happen in the middle of the page lifetime,
// it is more likely to have unintended consequences and would need to do different stuff.)
// - 'unload' supposedly always disables the bfcache.
window.addEventListener('unload', runShutdownTasks);
// - 'unload' supposedly always disables the bfcache, but is deprecated in Chrome.
// - 'beforeunload' may disable the bfcache but may be called more reliably than 'unload'.
window.addEventListener('beforeunload', runShutdownTasks);
// - 'pagehide' won't disable the bfcache but may be called more reliably than the others.

24
dom/webgpu/tests/cts/checkout/src/common/util/navigator_gpu.ts
View File

@@ -197,23 +197,25 @@ export function getGPU(recorder: TestCaseRecorder | null): GPU {
if (defaultRequestAdapterOptions) {
// eslint-disable-next-line @typescript-eslint/unbound-method
const oldFn = impl.requestAdapter;
impl.requestAdapter = function (
options?: GPURequestAdapterOptions
): Promise<GPUAdapter | null> {
const promise = oldFn.call(this, { ...defaultRequestAdapterOptions, ...options });
if (recorder) {
void promise.then(adapter => {
if (adapter) {
const origRequestAdapterFn = impl.requestAdapter;
// eslint-disable-next-line @typescript-eslint/unbound-method
Object.defineProperty(impl, 'requestAdapter', {
configurable: true,
async value(options?: GPURequestAdapterOptions) {
const adapter = await origRequestAdapterFn.call(this, {
...defaultRequestAdapterOptions,
...options,
});
if (recorder && adapter) {
const adapterInfo = adapter.info;
const infoString = `Adapter: ${adapterInfo.vendor} / ${adapterInfo.architecture} / ${adapterInfo.device}`;
recorder.debug(new ErrorWithExtra(infoString, () => ({ adapterInfo })));
}
return adapter;
},
});
}
return promise;
};
}
return impl;
}

220
dom/webgpu/tests/cts/checkout/src/resources/cache/hashes.json generated vendored
View File

@@ -1,112 +1,112 @@
{
"webgpu/shader/execution/binary/af_addition.bin": "8a6dae1a",
"webgpu/shader/execution/binary/af_logical.bin": "801f1d3",
"webgpu/shader/execution/binary/af_division.bin": "542849b0",
"webgpu/shader/execution/binary/af_matrix_addition.bin": "11e50be6",
"webgpu/shader/execution/binary/af_matrix_subtraction.bin": "ce90174f",
"webgpu/shader/execution/binary/af_multiplication.bin": "d1110a67",
"webgpu/shader/execution/binary/af_remainder.bin": "85c8dbd0",
"webgpu/shader/execution/binary/af_subtraction.bin": "a188d924",
"webgpu/shader/execution/binary/f16_addition.bin": "1aa58ad8",
"webgpu/shader/execution/binary/f16_logical.bin": "4a1c8221",
"webgpu/shader/execution/binary/f16_division.bin": "189722c1",
"webgpu/shader/execution/binary/f16_matrix_addition.bin": "d18b795d",
"webgpu/shader/execution/binary/f16_matrix_matrix_multiplication.bin": "d1ca04cd",
"webgpu/shader/execution/binary/f16_matrix_scalar_multiplication.bin": "74e7f534",
"webgpu/shader/execution/binary/f16_matrix_subtraction.bin": "725faf4a",
"webgpu/shader/execution/binary/f16_matrix_vector_multiplication.bin": "970e74ea",
"webgpu/shader/execution/binary/f16_multiplication.bin": "cc6b9ad1",
"webgpu/shader/execution/binary/f16_remainder.bin": "ef5b649",
"webgpu/shader/execution/binary/f16_subtraction.bin": "7affdaf5",
"webgpu/shader/execution/binary/f32_addition.bin": "66cd04fa",
"webgpu/shader/execution/binary/f32_logical.bin": "ccddd86",
"webgpu/shader/execution/binary/f32_division.bin": "39984166",
"webgpu/shader/execution/binary/f32_matrix_addition.bin": "8a6375d5",
"webgpu/shader/execution/binary/f32_matrix_matrix_multiplication.bin": "7a972729",
"webgpu/shader/execution/binary/f32_matrix_scalar_multiplication.bin": "67a9a7f8",
"webgpu/shader/execution/binary/f32_matrix_subtraction.bin": "bdead4ae",
"webgpu/shader/execution/binary/f32_matrix_vector_multiplication.bin": "61ba6fc7",
"webgpu/shader/execution/binary/f32_multiplication.bin": "ce9a8e70",
"webgpu/shader/execution/binary/f32_remainder.bin": "8e879118",
"webgpu/shader/execution/binary/f32_subtraction.bin": "e54a0b53",
"webgpu/shader/execution/binary/i32_arithmetic.bin": "2796c7a1",
"webgpu/shader/execution/binary/i32_comparison.bin": "b6cccd16",
"webgpu/shader/execution/binary/u32_arithmetic.bin": "b6cd9a78",
"webgpu/shader/execution/binary/u32_comparison.bin": "a79879",
"webgpu/shader/execution/abs.bin": "f36c9714",
"webgpu/shader/execution/acos.bin": "5b2c76ce",
"webgpu/shader/execution/acosh.bin": "2a75f9b8",
"webgpu/shader/execution/asin.bin": "6c642f6f",
"webgpu/shader/execution/asinh.bin": "bbfe9056",
"webgpu/shader/execution/atan.bin": "9ce43da3",
"webgpu/shader/execution/atan2.bin": "68fe0f2",
"webgpu/shader/execution/atanh.bin": "3963222",
"webgpu/shader/execution/bitcast.bin": "e3162a7e",
"webgpu/shader/execution/ceil.bin": "a676b1e",
"webgpu/shader/execution/clamp.bin": "14701cf7",
"webgpu/shader/execution/cos.bin": "1483b62b",
"webgpu/shader/execution/cosh.bin": "ce7f0632",
"webgpu/shader/execution/cross.bin": "f9a18bd5",
"webgpu/shader/execution/degrees.bin": "98276d75",
"webgpu/shader/execution/determinant.bin": "4a956856",
"webgpu/shader/execution/distance.bin": "22d0592a",
"webgpu/shader/execution/dot.bin": "ed60c916",
"webgpu/shader/execution/exp.bin": "6d7b1fbf",
"webgpu/shader/execution/exp2.bin": "91899596",
"webgpu/shader/execution/faceForward.bin": "44446c0b",
"webgpu/shader/execution/floor.bin": "549c5f0d",
"webgpu/shader/execution/fma.bin": "489c4998",
"webgpu/shader/execution/fract.bin": "cb3959f9",
"webgpu/shader/execution/frexp.bin": "2530b9b6",
"webgpu/shader/execution/inverseSqrt.bin": "4433898f",
"webgpu/shader/execution/ldexp.bin": "e37552e8",
"webgpu/shader/execution/length.bin": "3eeb0337",
"webgpu/shader/execution/log.bin": "87c4c21",
"webgpu/shader/execution/log2.bin": "8f826e9f",
"webgpu/shader/execution/max.bin": "60e2b9d2",
"webgpu/shader/execution/min.bin": "943cd5ce",
"webgpu/shader/execution/mix.bin": "9526816d",
"webgpu/shader/execution/modf.bin": "1e25f8b3",
"webgpu/shader/execution/normalize.bin": "de04cde2",
"webgpu/shader/execution/pack2x16float.bin": "4479a7f",
"webgpu/shader/execution/pow.bin": "c43650f6",
"webgpu/shader/execution/quantizeToF16.bin": "eb0e400b",
"webgpu/shader/execution/radians.bin": "e5608719",
"webgpu/shader/execution/reflect.bin": "8913d349",
"webgpu/shader/execution/refract.bin": "6ac45f2",
"webgpu/shader/execution/round.bin": "5bb21704",
"webgpu/shader/execution/saturate.bin": "8b7a0f64",
"webgpu/shader/execution/sign.bin": "22ced674",
"webgpu/shader/execution/sin.bin": "7bd2d5a2",
"webgpu/shader/execution/sinh.bin": "6b09bc46",
"webgpu/shader/execution/smoothstep.bin": "9caf5eb8",
"webgpu/shader/execution/sqrt.bin": "515cfcf2",
"webgpu/shader/execution/step.bin": "a657a4e7",
"webgpu/shader/execution/tan.bin": "b555744",
"webgpu/shader/execution/tanh.bin": "3e16eb6d",
"webgpu/shader/execution/transpose.bin": "80dabbe8",
"webgpu/shader/execution/trunc.bin": "3d4ef4d5",
"webgpu/shader/execution/unpack2x16float.bin": "c8d18fb8",
"webgpu/shader/execution/unpack2x16snorm.bin": "7a14d340",
"webgpu/shader/execution/unpack2x16unorm.bin": "16978649",
"webgpu/shader/execution/unpack4x8snorm.bin": "9f9a1b81",
"webgpu/shader/execution/unpack4x8unorm.bin": "c4ffba6b",
"webgpu/shader/execution/unary/af_arithmetic.bin": "4e816dcb",
"webgpu/shader/execution/unary/af_assignment.bin": "f1c510e5",
"webgpu/shader/execution/unary/bool_conversion.bin": "fc23c738",
"webgpu/shader/execution/unary/f16_arithmetic.bin": "502df71c",
"webgpu/shader/execution/unary/f16_conversion.bin": "8ba3360a",
"webgpu/shader/execution/unary/f32_arithmetic.bin": "90bd65ee",
"webgpu/shader/execution/unary/f32_conversion.bin": "54eb496a",
"webgpu/shader/execution/unary/i32_arithmetic.bin": "bc9bcacd",
"webgpu/shader/execution/unary/i32_conversion.bin": "1caf76fc",
"webgpu/shader/execution/unary/u32_conversion.bin": "ea69b1eb",
"webgpu/shader/execution/unary/ai_assignment.bin": "2b40f7c0",
"webgpu/shader/execution/binary/ai_arithmetic.bin": "65bb3107",
"webgpu/shader/execution/unary/ai_arithmetic.bin": "3dddf016",
"webgpu/shader/execution/binary/af_matrix_matrix_multiplication.bin": "f904c739",
"webgpu/shader/execution/binary/af_matrix_scalar_multiplication.bin": "7613eb4e",
"webgpu/shader/execution/binary/af_matrix_vector_multiplication.bin": "ccc2f487",
"webgpu/shader/execution/derivatives.bin": "d70042f3",
"webgpu/shader/execution/fwidth.bin": "224d4da0"
"webgpu/shader/execution/binary/af_addition.bin": "50e6a567",
"webgpu/shader/execution/binary/af_logical.bin": "156f7a3e",
"webgpu/shader/execution/binary/af_division.bin": "5fb5aad5",
"webgpu/shader/execution/binary/af_matrix_addition.bin": "4a10b9bf",
"webgpu/shader/execution/binary/af_matrix_subtraction.bin": "775955dd",
"webgpu/shader/execution/binary/af_multiplication.bin": "8f7cdc6c",
"webgpu/shader/execution/binary/af_remainder.bin": "f13de72f",
"webgpu/shader/execution/binary/af_subtraction.bin": "91cdd21e",
"webgpu/shader/execution/binary/f16_addition.bin": "6854bf3d",
"webgpu/shader/execution/binary/f16_logical.bin": "8ff07c74",
"webgpu/shader/execution/binary/f16_division.bin": "6ff84e12",
"webgpu/shader/execution/binary/f16_matrix_addition.bin": "57f7896",
"webgpu/shader/execution/binary/f16_matrix_matrix_multiplication.bin": "a30cd925",
"webgpu/shader/execution/binary/f16_matrix_scalar_multiplication.bin": "7319df75",
"webgpu/shader/execution/binary/f16_matrix_subtraction.bin": "b1c05ecf",
"webgpu/shader/execution/binary/f16_matrix_vector_multiplication.bin": "21b437ec",
"webgpu/shader/execution/binary/f16_multiplication.bin": "4638fb34",
"webgpu/shader/execution/binary/f16_remainder.bin": "44574387",
"webgpu/shader/execution/binary/f16_subtraction.bin": "820e75de",
"webgpu/shader/execution/binary/f32_addition.bin": "a4f72976",
"webgpu/shader/execution/binary/f32_logical.bin": "535674fe",
"webgpu/shader/execution/binary/f32_division.bin": "4959d8cd",
"webgpu/shader/execution/binary/f32_matrix_addition.bin": "bb179d37",
"webgpu/shader/execution/binary/f32_matrix_matrix_multiplication.bin": "503ab436",
"webgpu/shader/execution/binary/f32_matrix_scalar_multiplication.bin": "234e8380",
"webgpu/shader/execution/binary/f32_matrix_subtraction.bin": "55b30efc",
"webgpu/shader/execution/binary/f32_matrix_vector_multiplication.bin": "4e7e58bf",
"webgpu/shader/execution/binary/f32_multiplication.bin": "6a2a2d91",
"webgpu/shader/execution/binary/f32_remainder.bin": "f8e1d804",
"webgpu/shader/execution/binary/f32_subtraction.bin": "fce2ee14",
"webgpu/shader/execution/binary/i32_arithmetic.bin": "9bfbc49b",
"webgpu/shader/execution/binary/i32_comparison.bin": "537c83e1",
"webgpu/shader/execution/binary/u32_arithmetic.bin": "2f58bba2",
"webgpu/shader/execution/binary/u32_comparison.bin": "ba9e997d",
"webgpu/shader/execution/abs.bin": "7d9e6b9c",
"webgpu/shader/execution/acos.bin": "14388910",
"webgpu/shader/execution/acosh.bin": "94a4bdba",
"webgpu/shader/execution/asin.bin": "349b6e0e",
"webgpu/shader/execution/asinh.bin": "28771ac3",
"webgpu/shader/execution/atan.bin": "1bc1d94d",
"webgpu/shader/execution/atan2.bin": "38b37c44",
"webgpu/shader/execution/atanh.bin": "a5f7aee5",
"webgpu/shader/execution/bitcast.bin": "a8994ad4",
"webgpu/shader/execution/ceil.bin": "73f16d7b",
"webgpu/shader/execution/clamp.bin": "a690f522",
"webgpu/shader/execution/cos.bin": "89be2f32",
"webgpu/shader/execution/cosh.bin": "6a0f3e8b",
"webgpu/shader/execution/cross.bin": "aa9d40a1",
"webgpu/shader/execution/degrees.bin": "8026a5db",
"webgpu/shader/execution/determinant.bin": "1694a349",
"webgpu/shader/execution/distance.bin": "a7638a71",
"webgpu/shader/execution/dot.bin": "f0ef226f",
"webgpu/shader/execution/exp.bin": "435e1646",
"webgpu/shader/execution/exp2.bin": "804c653e",
"webgpu/shader/execution/faceForward.bin": "8c738be9",
"webgpu/shader/execution/floor.bin": "f6441e05",
"webgpu/shader/execution/fma.bin": "4ee13b1a",
"webgpu/shader/execution/fract.bin": "c65b7672",
"webgpu/shader/execution/frexp.bin": "4ac71f4b",
"webgpu/shader/execution/inverseSqrt.bin": "1cbcea5d",
"webgpu/shader/execution/ldexp.bin": "b4e969fb",
"webgpu/shader/execution/length.bin": "55a89c1e",
"webgpu/shader/execution/log.bin": "b06012a8",
"webgpu/shader/execution/log2.bin": "9417099a",
"webgpu/shader/execution/max.bin": "e7a5826",
"webgpu/shader/execution/min.bin": "7ef323e1",
"webgpu/shader/execution/mix.bin": "6eb306f",
"webgpu/shader/execution/modf.bin": "a9ad9cfc",
"webgpu/shader/execution/normalize.bin": "c15ea8",
"webgpu/shader/execution/pack2x16float.bin": "f2cedced",
"webgpu/shader/execution/pow.bin": "71979830",
"webgpu/shader/execution/quantizeToF16.bin": "b6bfcd52",
"webgpu/shader/execution/radians.bin": "9e5a449a",
"webgpu/shader/execution/reflect.bin": "dd2159f6",
"webgpu/shader/execution/refract.bin": "209a8278",
"webgpu/shader/execution/round.bin": "ffb75a5e",
"webgpu/shader/execution/saturate.bin": "97db14f4",
"webgpu/shader/execution/sign.bin": "34388f8e",
"webgpu/shader/execution/sin.bin": "96bf69b3",
"webgpu/shader/execution/sinh.bin": "6602a539",
"webgpu/shader/execution/smoothstep.bin": "aed55251",
"webgpu/shader/execution/sqrt.bin": "35613b62",
"webgpu/shader/execution/step.bin": "1349c866",
"webgpu/shader/execution/tan.bin": "806d67e8",
"webgpu/shader/execution/tanh.bin": "2698b5d1",
"webgpu/shader/execution/transpose.bin": "4ce90543",
"webgpu/shader/execution/trunc.bin": "4bbb7aaf",
"webgpu/shader/execution/unpack2x16float.bin": "6b01b9d6",
"webgpu/shader/execution/unpack2x16snorm.bin": "e8c8c841",
"webgpu/shader/execution/unpack2x16unorm.bin": "4c869eb8",
"webgpu/shader/execution/unpack4x8snorm.bin": "794c9465",
"webgpu/shader/execution/unpack4x8unorm.bin": "26501fe4",
"webgpu/shader/execution/unary/af_arithmetic.bin": "7a7a4fdc",
"webgpu/shader/execution/unary/af_assignment.bin": "11a8b60c",
"webgpu/shader/execution/unary/bool_conversion.bin": "be5e9d2d",
"webgpu/shader/execution/unary/f16_arithmetic.bin": "c98e7af3",
"webgpu/shader/execution/unary/f16_conversion.bin": "931541aa",
"webgpu/shader/execution/unary/f32_arithmetic.bin": "99619832",
"webgpu/shader/execution/unary/f32_conversion.bin": "9a872074",
"webgpu/shader/execution/unary/i32_arithmetic.bin": "e68d3b9d",
"webgpu/shader/execution/unary/i32_conversion.bin": "a09e6602",
"webgpu/shader/execution/unary/u32_conversion.bin": "2c0e8598",
"webgpu/shader/execution/unary/ai_assignment.bin": "1302476e",
"webgpu/shader/execution/binary/ai_arithmetic.bin": "2029b198",
"webgpu/shader/execution/unary/ai_arithmetic.bin": "9622dbf2",
"webgpu/shader/execution/binary/af_matrix_matrix_multiplication.bin": "a7e239c4",
"webgpu/shader/execution/binary/af_matrix_scalar_multiplication.bin": "f067a039",
"webgpu/shader/execution/binary/af_matrix_vector_multiplication.bin": "7936213b",
"webgpu/shader/execution/derivatives.bin": "eda7415f",
"webgpu/shader/execution/fwidth.bin": "1b331b33"
}

BIN
dom/webgpu/tests/cts/checkout/src/resources/cache/webgpu/shader/execution/asinh.bin vendored
View File

Binary file not shown.

BIN
dom/webgpu/tests/cts/checkout/src/resources/cache/webgpu/shader/execution/atanh.bin vendored
View File

Binary file not shown.

BIN
dom/webgpu/tests/cts/checkout/src/resources/cache/webgpu/shader/execution/binary/af_matrix_matrix_multiplication.bin vendored
View File

Binary file not shown.

BIN
dom/webgpu/tests/cts/checkout/src/resources/cache/webgpu/shader/execution/binary/af_matrix_vector_multiplication.bin vendored
View File

Binary file not shown.

BIN
dom/webgpu/tests/cts/checkout/src/resources/cache/webgpu/shader/execution/binary/f32_addition.bin vendored
View File

Binary file not shown.

BIN
dom/webgpu/tests/cts/checkout/src/resources/cache/webgpu/shader/execution/binary/f32_matrix_addition.bin vendored
View File

Binary file not shown.

BIN
dom/webgpu/tests/cts/checkout/src/resources/cache/webgpu/shader/execution/binary/f32_matrix_matrix_multiplication.bin vendored
View File

Binary file not shown.

BIN
dom/webgpu/tests/cts/checkout/src/resources/cache/webgpu/shader/execution/binary/f32_matrix_subtraction.bin vendored
View File

Binary file not shown.

BIN
dom/webgpu/tests/cts/checkout/src/resources/cache/webgpu/shader/execution/binary/f32_matrix_vector_multiplication.bin vendored
View File

Binary file not shown.

BIN
dom/webgpu/tests/cts/checkout/src/resources/cache/webgpu/shader/execution/binary/f32_subtraction.bin vendored
View File

Binary file not shown.

BIN
dom/webgpu/tests/cts/checkout/src/resources/cache/webgpu/shader/execution/cross.bin vendored
View File

Binary file not shown.

BIN
dom/webgpu/tests/cts/checkout/src/resources/cache/webgpu/shader/execution/derivatives.bin vendored
View File

Binary file not shown.

BIN
dom/webgpu/tests/cts/checkout/src/resources/cache/webgpu/shader/execution/distance.bin vendored
View File

Binary file not shown.

BIN
dom/webgpu/tests/cts/checkout/src/resources/cache/webgpu/shader/execution/dot.bin vendored
View File

Binary file not shown.

BIN
dom/webgpu/tests/cts/checkout/src/resources/cache/webgpu/shader/execution/faceForward.bin vendored
View File

Binary file not shown.

BIN
dom/webgpu/tests/cts/checkout/src/resources/cache/webgpu/shader/execution/fma.bin vendored
View File

Binary file not shown.

BIN
dom/webgpu/tests/cts/checkout/src/resources/cache/webgpu/shader/execution/fwidth.bin vendored
View File

Binary file not shown.

BIN
dom/webgpu/tests/cts/checkout/src/resources/cache/webgpu/shader/execution/length.bin vendored
View File

Binary file not shown.

BIN
dom/webgpu/tests/cts/checkout/src/resources/cache/webgpu/shader/execution/mix.bin vendored
View File

Binary file not shown.

BIN
dom/webgpu/tests/cts/checkout/src/resources/cache/webgpu/shader/execution/normalize.bin vendored
View File

Binary file not shown.

BIN
dom/webgpu/tests/cts/checkout/src/resources/cache/webgpu/shader/execution/reflect.bin vendored
View File

Binary file not shown.

BIN
dom/webgpu/tests/cts/checkout/src/resources/cache/webgpu/shader/execution/refract.bin vendored
View File

Binary file not shown.

BIN
dom/webgpu/tests/cts/checkout/src/resources/cache/webgpu/shader/execution/smoothstep.bin vendored
View File

Binary file not shown.

9
dom/webgpu/tests/cts/checkout/src/stress/shaders/slow.spec.ts
View File

@@ -3,9 +3,10 @@ Stress tests covering robustness in the presence of slow shaders.
`;
import { makeTestGroup } from '../../common/framework/test_group.js';
import { GPUTest, TextureTestMixin } from '../../webgpu/gpu_test.js';
import { GPUTest } from '../../webgpu/gpu_test.js';
import * as ttu from '../../webgpu/texture_test_utils.js';
export const g = makeTestGroup(TextureTestMixin(GPUTest));
export const g = makeTestGroup(GPUTest);
g.test('compute')
.desc(`Tests execution of compute passes with very long-running dispatch operations.`)
@@ -110,7 +111,7 @@ g.test('vertex')
pass.draw(1);
pass.end();
t.device.queue.submit([encoder.finish()]);
t.expectSinglePixelComparisonsAreOkInTexture({ texture: renderTarget }, [
ttu.expectSinglePixelComparisonsAreOkInTexture(t, { texture: renderTarget }, [
{
coord: { x: 1, y: 1 },
exp: new Uint8Array([255, 255, 0, 255]),
@@ -182,7 +183,7 @@ g.test('fragment')
pass.draw(1);
pass.end();
t.device.queue.submit([encoder.finish()]);
t.expectSinglePixelComparisonsAreOkInTexture({ texture: renderTarget }, [
ttu.expectSinglePixelComparisonsAreOkInTexture(t, { texture: renderTarget }, [
{
coord: { x: 1, y: 1 },
exp: new Uint8Array([255, 255, 0, 255]),

90
dom/webgpu/tests/cts/checkout/src/unittests/floating_point.spec.ts
View File

@@ -4048,6 +4048,23 @@ const kAdditionInterval64BitsNormalCases = {
{ input: [0.1, -0.1], expected: [reinterpretU32AsF32(0x3dcccccc) + reinterpretU32AsF32(0xbdcccccd), reinterpretU32AsF32(0x3dcccccd) + reinterpretU32AsF32(0xbdcccccc)] }, // ~0.0
// -0.1+0.1 expect f32 interval [0xBDCCCCCD+0x3DCCCCCC, 0xBDCCCCCC+0x3DCCCCCD]
{ input: [-0.1, 0.1], expected: [reinterpretU32AsF32(0xbdcccccd) + reinterpretU32AsF32(0x3dcccccc), reinterpretU32AsF32(0xbdcccccc) + reinterpretU32AsF32(0x3dcccccd)] }, // ~0.0
{ input: [1, kValue.f32.positive.min], expected: [1.0, reinterpretU32AsF32(0x3f800001)] },
{ input: [1, kValue.f32.negative.max], expected: [reinterpretU32AsF32(0x3f7fffff), 1.0] },
{ input: [-1, kValue.f32.positive.min], expected: [-1.0, reinterpretU32AsF32(0xbf7fffff)] },
{ input: [-1, kValue.f32.negative.max], expected: [reinterpretU32AsF32(0xbf800001), -1.0] },
{ input: [1, kValue.f32.positive.max], expected: kUnboundedEndpoints },
{ input: [1, kValue.f32.negative.min], expected: [reinterpretU32AsF32(0xff7fffff), reinterpretU32AsF32(0xff7ffffe)] },
{ input: [-1, kValue.f32.positive.max], expected: [reinterpretU32AsF32(0x7f7ffffe), reinterpretU32AsF32(0x7f7fffff)] },
{ input: [-1, kValue.f32.negative.min], expected: kUnboundedEndpoints },
// Symmetry with the above test cases.
{ input: [kValue.f32.positive.min, 1], expected: [1.0, reinterpretU32AsF32(0x3f800001)] },
{ input: [kValue.f32.negative.max, 1], expected: [reinterpretU32AsF32(0x3f7fffff), 1.0] },
{ input: [kValue.f32.positive.min, -1], expected: [-1.0, reinterpretU32AsF32(0xbf7fffff)] },
{ input: [kValue.f32.negative.max, -1], expected: [reinterpretU32AsF32(0xbf800001), -1.0] },
{ input: [kValue.f32.positive.max, 1], expected: kUnboundedEndpoints },
{ input: [kValue.f32.negative.min, 1], expected: [reinterpretU32AsF32(0xff7fffff), reinterpretU32AsF32(0xff7ffffe)] },
{ input: [kValue.f32.positive.max, -1], expected: [reinterpretU32AsF32(0x7f7ffffe), reinterpretU32AsF32(0x7f7fffff)] },
{ input: [kValue.f32.negative.min, -1], expected: kUnboundedEndpoints },
] as ScalarPairToIntervalCase[],
f16: [
// 0.1 falls between f16 0x2E66 and 0x2E67, -0.1 falls between f16 0xAE67 and 0xAE66
@@ -5017,6 +5034,23 @@ const kSubtractionInterval64BitsNormalCases = {
{ input: [0.1, -0.1], expected: [reinterpretU32AsF32(0x3dcccccc)-reinterpretU32AsF32(0xbdcccccc), reinterpretU32AsF32(0x3dcccccd)-reinterpretU32AsF32(0xbdcccccd)] },
// Expect f32 interval [0xBDCCCCCD-0x3DCCCCCD, 0xBDCCCCCC-0x3DCCCCCC]
{ input: [-0.1, 0.1], expected: [reinterpretU32AsF32(0xbdcccccd)-reinterpretU32AsF32(0x3dcccccd), reinterpretU32AsF32(0xbdcccccc)-reinterpretU32AsF32(0x3dcccccc)] },
{ input: [1, kValue.f32.positive.min], expected: [reinterpretU32AsF32(0x3f7fffff), 1.0] },
{ input: [1, kValue.f32.negative.max], expected: [ 1.0, reinterpretU32AsF32(0x3f800001)] },
{ input: [-1, kValue.f32.positive.min], expected: [reinterpretU32AsF32(0xbf800001), -1.0] },
{ input: [-1, kValue.f32.negative.max], expected: [-1.0, reinterpretU32AsF32(0xbf7fffff)] },
{ input: [1, kValue.f32.positive.max], expected: [reinterpretU32AsF32(0xff7fffff), reinterpretU32AsF32(0xff7ffffe)]},
{ input: [1, kValue.f32.negative.min], expected: kUnboundedEndpoints},
{ input: [-1, kValue.f32.positive.max], expected:kUnboundedEndpoints},
{ input: [-1, kValue.f32.negative.min], expected: [reinterpretU32AsF32(0x7f7ffffe) , reinterpretU32AsF32(0x7f7fffff)] },
// Symmetric with above (expected will be anti-symmetric)
{ input: [kValue.f32.positive.min, 1], expected: [-1.0 , reinterpretU32AsF32(0xbf7fffff)] },
{ input: [kValue.f32.negative.max, 1], expected: [reinterpretU32AsF32(0xbf800001), -1.0] },
{ input: [kValue.f32.positive.min, -1], expected: [1.0, reinterpretU32AsF32(0x3f800001)] },
{ input: [kValue.f32.negative.max, -1], expected: [reinterpretU32AsF32(0x3f7fffff), 1.0] },
{ input: [kValue.f32.positive.max, 1], expected: [reinterpretU32AsF32(0x7f7ffffe), reinterpretU32AsF32(0x7f7fffff)]},
{ input: [kValue.f32.negative.min, 1], expected: kUnboundedEndpoints},
{ input: [kValue.f32.positive.max, -1], expected:kUnboundedEndpoints},
{ input: [kValue.f32.negative.min, -1], expected: [reinterpretU32AsF32(0xff7fffff) , reinterpretU32AsF32(0xff7ffffe)] },
] as ScalarPairToIntervalCase[],
f16: [
// 0.1 falls between f16 0x2E66 and 0x2E67, -0.1 falls between f16 0xAE67 and 0xAE66
@@ -5330,16 +5364,18 @@ const kMixImpreciseIntervalCases = {
{ input: [-1.0, 1.0, 0.9], expected: [reinterpretU64AsF64(0x3fe9_9999_8000_0000n), reinterpretU64AsF64(0x3fe9_9999_c000_0000n)] }, // ~0.8
// Showing how precise and imprecise versions diff
// Note that this expectation is 0 in f32 as |10.0| is much smaller than
// |f32.negative.min|.
// So that 10 - f32.negative.min == -f32.negative.min even in f64.
{ input: [kValue.f32.negative.min, 10.0, 1.0], expected: 0.0 },
// -10.0 is the same, much smaller than f32.negative.min
{ input: [kValue.f32.negative.min, -10.0, 1.0], expected: 0.0 },
// Note that this expectation is unbounded [-inf,inf] in f32 as |10.0| is much smaller than
// |f32.negative.min|. The implementation of imprecise is is := x + (y - x) * z
// So that 10 - f32.negative.min == [f32.positive.max, inf] due to correctly rounding of unbounded precision.
{ input: [kValue.f32.negative.min, 10.0, 1.0], expected: kUnboundedEndpoints},
// -10.0 is the same, however due to smaller than f32.negative.min we end up with [ULP_neg(f32.positive.max), f32.positive.max]
{ input: [kValue.f32.negative.min, -10.0, 1.0], expected: [reinterpretU32AsF32(0xf3800000), 0.0] },
{ input: [kValue.f32.negative.min, 10.0, 5.0], expected: kUnboundedEndpoints },
{ input: [kValue.f32.negative.min, -10.0, 5.0], expected: kUnboundedEndpoints },
{ input: [kValue.f32.negative.min, 10.0, 0.5], expected: reinterpretU32AsF32(0xfeffffff) },
{ input: [kValue.f32.negative.min, -10.0, 0.5], expected: reinterpretU32AsF32(0xfeffffff) },
{ input: [kValue.f32.negative.min, 10.0, 0.5], expected: kUnboundedEndpoints },
{ input: [kValue.f32.negative.min, -10.0, 0.5], expected: [reinterpretU32AsF32(0xff000000), reinterpretU32AsF32(0xfeffffff) ]},
// Test the case of unbounded precision of mix when implementing the subtraction intermediate value.
{ input: [kValue.f32.positive.min, 1.0, kValue.f32.positive.min], expected: [reinterpretU32AsF32(0x00800000),reinterpretU32AsF32(0x01000000)]},
] as ScalarTripleToIntervalCase[],
f16: [
// [0.0, 1.0] cases
@@ -5470,8 +5506,8 @@ const kMixPreciseIntervalCases = {
{ input: [kValue.f32.negative.min, -10.0, 1.0], expected: -10 },
{ input: [kValue.f32.negative.min, 10.0, 5.0], expected: kUnboundedEndpoints },
{ input: [kValue.f32.negative.min, -10.0, 5.0], expected: kUnboundedEndpoints },
{ input: [kValue.f32.negative.min, 10.0, 0.5], expected: reinterpretU32AsF32(0xfeffffff) },
{ input: [kValue.f32.negative.min, -10.0, 0.5], expected: reinterpretU32AsF32(0xfeffffff) },
{ input: [kValue.f32.negative.min, 10.0, 0.5], expected: [reinterpretU32AsF32(0xfeffffff), reinterpretU32AsF32(0xfefffffe) ] },
{ input: [kValue.f32.negative.min, -10.0, 0.5], expected: [reinterpretU32AsF32(0xff000000),reinterpretU32AsF32(0xfeffffff) ] },
// Intermediate OOB
{ input: [1.0, 2.0, kPlusOneULPFunctions['f32'](kValue.f32.positive.max / 2)], expected: kUnboundedEndpoints },
@@ -5595,10 +5631,10 @@ const kSmoothStepIntervalCases = {
{ input: [0, -2, -1], expected: [reinterpretU32AsF32(0x3efffff8), reinterpretU32AsF32(0x3f000007)] }, // ~0.5
{ input: [0, -2, -0.5], expected: [reinterpretU32AsF32(0x3e1ffffb), reinterpretU32AsF32(0x3e200007)] }, // ~0.15625...
// Subnormals
{ input: [kValue.f32.positive.subnormal.max, 2, 1], expected: [reinterpretU32AsF32(0x3efffff8), reinterpretU32AsF32(0x3f000007)] }, // ~0.5
{ input: [kValue.f32.positive.subnormal.min, 2, 1], expected: [reinterpretU32AsF32(0x3efffff8), reinterpretU32AsF32(0x3f000007)] }, // ~0.5
{ input: [kValue.f32.negative.subnormal.max, 2, 1], expected: [reinterpretU32AsF32(0x3efffff8), reinterpretU32AsF32(0x3f000007)] }, // ~0.5
{ input: [kValue.f32.negative.subnormal.min, 2, 1], expected: [reinterpretU32AsF32(0x3efffff8), reinterpretU32AsF32(0x3f000007)] }, // ~0.5
{ input: [kValue.f32.positive.subnormal.max, 2, 1], expected: [reinterpretU32AsF32(0x3efffff4), reinterpretU32AsF32(0x3f00000b)] }, // ~0.5
{ input: [kValue.f32.positive.subnormal.min, 2, 1], expected: [reinterpretU32AsF32(0x3efffff4), reinterpretU32AsF32(0x3f00000b)] }, // ~0.5
{ input: [kValue.f32.negative.subnormal.max, 2, 1], expected: [reinterpretU32AsF32(0x3efffff2), reinterpretU32AsF32(0x3f00000c)] }, // ~0.5
{ input: [kValue.f32.negative.subnormal.min, 2, 1], expected: [reinterpretU32AsF32(0x3efffff2), reinterpretU32AsF32(0x3f00000c)] }, // ~0.5
{ input: [0, 2, kValue.f32.positive.subnormal.max], expected: [0, kValue.f32.positive.subnormal.min] },
{ input: [0, 2, kValue.f32.positive.subnormal.min], expected: [0, kValue.f32.positive.subnormal.min] },
{ input: [0, 2, kValue.f32.negative.subnormal.max], expected: [0, kValue.f32.positive.subnormal.min] },
@@ -5608,10 +5644,10 @@ const kSmoothStepIntervalCases = {
{ input: [1, 0, 1], expected: [0, kValue.f32.positive.subnormal.min] },
{ input: [1, 0, 0], expected: [reinterpretU32AsF32(0x3f7ffffa), reinterpretU32AsF32(0x3f800003)] }, // ~1
// Subnormals
{ input: [2, kValue.f32.positive.subnormal.max, 1], expected: [reinterpretU32AsF32(0x3efffff8), reinterpretU32AsF32(0x3f000007)] }, // ~0.5
{ input: [2, kValue.f32.positive.subnormal.min, 1], expected: [reinterpretU32AsF32(0x3efffff8), reinterpretU32AsF32(0x3f000007)] }, // ~0.5
{ input: [2, kValue.f32.negative.subnormal.max, 1], expected: [reinterpretU32AsF32(0x3efffff8), reinterpretU32AsF32(0x3f000007)] }, // ~0.5
{ input: [2, kValue.f32.negative.subnormal.min, 1], expected: [reinterpretU32AsF32(0x3efffff8), reinterpretU32AsF32(0x3f000007)] }, // ~0.5
{ input: [2, kValue.f32.positive.subnormal.max, 1], expected: [reinterpretU32AsF32(0x3efffff6), reinterpretU32AsF32(0x3f00000b)] }, // ~0.5
{ input: [2, kValue.f32.positive.subnormal.min, 1], expected: [reinterpretU32AsF32(0x3efffff6), reinterpretU32AsF32(0x3f00000b)] }, // ~0.5
{ input: [2, kValue.f32.negative.subnormal.max, 1], expected: [reinterpretU32AsF32(0x3efffff4), reinterpretU32AsF32(0x3f000008)] }, // ~0.5
{ input: [2, kValue.f32.negative.subnormal.min, 1], expected: [reinterpretU32AsF32(0x3efffff4), reinterpretU32AsF32(0x3f000008)] }, // ~0.5
] as ScalarTripleToIntervalCase[],
f16: [
// Normals
@@ -6056,14 +6092,16 @@ g.test('distanceIntervalVector')
// prettier-ignore
const kDotIntervalCases = {
f32: [
// Inputs with large values but cancel out to finite result. In these cases, 2.0*2.0 = 4.0 and
// 3.0*3.0 = 9.0 is much smaller than kValue.f32.positive.max, as a result
// kValue.f32.positive.max + 9.0 = kValue.f32.positive.max in f32 and even f64. So, if the
// positive and negative large number cancel each other first, the result would be
// 2.0*2.0+3.0*3.0 = 13. Otherwise, the result would be 0.0 or 4.0 or 9.0.
// https://github.com/gpuweb/cts/issues/2155
{ input: [[kValue.f32.positive.max, 1.0, 2.0, 3.0], [-1.0, kValue.f32.positive.max, -2.0, -3.0]], expected: [-13, 0] },
{ input: [[kValue.f32.positive.max, 1.0, 2.0, 3.0], [1.0, kValue.f32.negative.min, 2.0, 3.0]], expected: [0, 13] },
// Due to unbounded precision, intermediate correctly rounded computations could result in intervals that include infinity.
// This is because the computation kValue.f32.negative.min - 4.0 = [-inf, kValue.f32.negative.min]
// due to the ULP_neg(kValue.f32.negative.min) => -inf
// See: https://www.w3.org/TR/WGSL/#floating-point-accuracy
{ input: [[kValue.f32.positive.max, 1.0, 2.0, 3.0], [-1.0, kValue.f32.positive.max, -2.0, -3.0]], expected: kUnboundedEndpoints},
{ input: [[kValue.f32.positive.max, 1.0, 2.0, 3.0], [1.0, kValue.f32.negative.min, 2.0, 3.0]], expected: kUnboundedEndpoints },
// Exactly as above but simply 2 ulp magnitude smaller (away from kValue.f32.positive.max).
// This avoids intermediate intervals that overflow into infinity and we end up with large but finite intervals.
{ input: [[reinterpretU32AsF32(0x7f7ffffd), 1.0, 2.0, 3.0], [-1.0, kValue.f32.positive.max, -2.0, -3.0]], expected: [0.0, reinterpretU32AsF32(0x74000000)]},
{ input: [[reinterpretU32AsF32(0x7f7ffffd), 1.0, 2.0, 3.0], [1.0, kValue.f32.negative.min, 2.0, 3.0]], expected: [reinterpretU32AsF32(0xf4000000), 0.0] },
] as VectorPairToIntervalCase[],
f16: [
// Inputs with large values but cancel out to finite result. In these cases, 2.0*2.0 = 4.0 and

16
dom/webgpu/tests/cts/checkout/src/webgpu/api/operation/adapter/requestDevice.spec.ts
View File

@@ -173,20 +173,8 @@ g.test('stale')
);
}
const kTimeoutMS = 1000;
const lostDevice = await t.requestDeviceTracked(adapter);
const lost = await raceWithRejectOnTimeout(
lostDevice.lost,
kTimeoutMS,
'adapter was not stale'
);
t.expect(lost.reason === 'unknown');
// Make sure to destroy the valid device after trying to get a second one. Otherwise, the second
// device may fail because the adapter is put into an invalid state from the destroy.
if (device) {
device.destroy();
}
// Since the adapter is consumed now, requesting another device is not possible anymore.
t.shouldReject('OperationError', t.requestDeviceTracked(adapter));
});
g.test('features,unknown')

10
dom/webgpu/tests/cts/checkout/src/webgpu/api/operation/command_buffer/copyTextureToTexture.spec.ts
View File

@@ -24,7 +24,8 @@ import {
textureDimensionAndFormatCompatible,
textureFormatsAreViewCompatible,
} from '../../../format_info.js';
import { AllFeaturesMaxLimitsGPUTest, TextureTestMixin } from '../../../gpu_test.js';
import { AllFeaturesMaxLimitsGPUTest } from '../../../gpu_test.js';
import * as ttu from '../../../texture_test_utils.js';
import { checkElementsEqual } from '../../../util/check_contents.js';
import { align } from '../../../util/math.js';
import { physicalMipSize } from '../../../util/texture/base.js';
@@ -35,7 +36,7 @@ import { findFailedPixels } from '../../../util/texture/texture_ok.js';
const dataGenerator = new DataArrayGenerator();
class F extends TextureTestMixin(AllFeaturesMaxLimitsGPUTest) {
class F extends AllFeaturesMaxLimitsGPUTest {
GetInitialDataPerMipLevel(
dimension: GPUTextureDimension,
textureSize: Required<GPUExtent3DDict>,
@@ -220,7 +221,7 @@ class F extends TextureTestMixin(AllFeaturesMaxLimitsGPUTest) {
// Execute the equivalent of `copyTextureToTexture`, copying
// from `initialSrcData` to `expectedData`.
this.updateLinearTextureDataSubBox(dstFormat, appliedSize, {
ttu.updateLinearTextureDataSubBox(this, dstFormat, appliedSize, {
src: {
dataLayout: {
bytesPerRow: srcBlocksPerRow * bytesPerBlock,
@@ -253,7 +254,8 @@ class F extends TextureTestMixin(AllFeaturesMaxLimitsGPUTest) {
dstTextureSizeAtLevel
);
this.expectTexturesToMatchByRendering(
ttu.expectTexturesToMatchByRendering(
this,
dstTexture,
expectedTexture,
dstCopyLevel,

21
dom/webgpu/tests/cts/checkout/src/webgpu/api/operation/command_buffer/image_copy.spec.ts
View File

@@ -60,7 +60,8 @@ import {
canCopyToAllAspectsOfTextureFormat,
canCopyFromAllAspectsOfTextureFormat,
} from '../../../format_info.js';
import { AllFeaturesMaxLimitsGPUTest, TextureTestMixin } from '../../../gpu_test.js';
import { AllFeaturesMaxLimitsGPUTest } from '../../../gpu_test.js';
import * as ttu from '../../../texture_test_utils.js';
import { checkElementsEqual } from '../../../util/check_contents.js';
import { align } from '../../../util/math.js';
import { physicalMipSizeFromTexture } from '../../../util/texture/base.js';
@@ -125,7 +126,7 @@ const kMethodsToTest = [
const dataGenerator = new DataArrayGenerator();
const altDataGenerator = new DataArrayGenerator();
class ImageCopyTest extends TextureTestMixin(AllFeaturesMaxLimitsGPUTest) {
class ImageCopyTest extends AllFeaturesMaxLimitsGPUTest {
/**
* This is used for testing passing undefined members of `GPUTexelCopyBufferLayout` instead of actual
* values where possible. Passing arguments as values and not as objects so that they are passed
@@ -292,8 +293,8 @@ class ImageCopyTest extends TextureTestMixin(AllFeaturesMaxLimitsGPUTest) {
{
const rowLength = bytesInACompleteRow(size.width, format);
let lastOffset = 0;
for (const texel of this.iterateBlockRows(size, format)) {
const offset = this.getTexelOffsetInBytes(dataLayout, format, texel, zero);
for (const texel of ttu.iterateBlockRows(size, format)) {
const offset = ttu.getTexelOffsetInBytes(dataLayout, format, texel, zero);
const actualPart = actual.subarray(lastOffset, offset);
const expectedPart = expected.subarray(lastOffset, offset);
const error = checkElementsEqual(actualPart, expectedPart);
@@ -467,7 +468,7 @@ class ImageCopyTest extends TextureTestMixin(AllFeaturesMaxLimitsGPUTest) {
// update the data for the entire mip level with the data
// that would be copied to the "actual" texture
this.updateLinearTextureDataSubBox(format, copySize, {
ttu.updateLinearTextureDataSubBox(this, format, copySize, {
src: {
dataLayout: expectedDataLayout,
origin: { x: 0, y: 0, z: 0 },
@@ -488,7 +489,8 @@ class ImageCopyTest extends TextureTestMixin(AllFeaturesMaxLimitsGPUTest) {
mipSize
);
this.expectTexturesToMatchByRendering(
ttu.expectTexturesToMatchByRendering(
this,
actualTexture,
expectedTexture,
mipLevel,
@@ -542,7 +544,7 @@ class ImageCopyTest extends TextureTestMixin(AllFeaturesMaxLimitsGPUTest) {
// bufferData has ...... in it.
// Update bufferData to have the same contents as buffer.
// When done, bufferData now has t.t.t. because the rows are padded.
this.updateLinearTextureDataSubBox(format, checkSize, {
ttu.updateLinearTextureDataSubBox(this, format, checkSize, {
src: {
dataLayout: expectedDataLayout,
origin: { x: 0, y: 0, z: 0 },
@@ -592,7 +594,7 @@ class ImageCopyTest extends TextureTestMixin(AllFeaturesMaxLimitsGPUTest) {
// other eventual async expectations to ensure it will be correct.
this.eventualAsyncExpectation(async () => {
const readback = await readbackPromise;
this.updateLinearTextureDataSubBox(format, copySize, {
ttu.updateLinearTextureDataSubBox(this, format, copySize, {
dest: {
dataLayout: { offset: 0, ...fullTextureCopyLayout },
origin,
@@ -701,7 +703,8 @@ class ImageCopyTest extends TextureTestMixin(AllFeaturesMaxLimitsGPUTest) {
mipLevel,
});
const fullData = this.copyWholeTextureToNewBuffer(
const fullData = ttu.copyWholeTextureToNewBuffer(
this,
{ texture, mipLevel },
fullTextureCopyLayout
);

20
dom/webgpu/tests/cts/checkout/src/webgpu/api/operation/command_buffer/render/state_tracking.spec.ts
View File

@@ -6,10 +6,11 @@ Equivalent tests for viewport/scissor/blend/reference are in render/dynamic_stat
`;
import { makeTestGroup } from '../../../../../common/framework/test_group.js';
import { AllFeaturesMaxLimitsGPUTest, TextureTestMixin } from '../../../../gpu_test.js';
import { AllFeaturesMaxLimitsGPUTest } from '../../../../gpu_test.js';
import * as ttu from '../../../../texture_test_utils.js';
import { TexelView } from '../../../../util/texture/texel_view.js';
class VertexAndIndexStateTrackingTest extends TextureTestMixin(AllFeaturesMaxLimitsGPUTest) {
class VertexAndIndexStateTrackingTest extends AllFeaturesMaxLimitsGPUTest {
GetRenderPipelineForTest(arrayStride: number): GPURenderPipeline {
return this.device.createRenderPipeline({
layout: 'auto',
@@ -171,7 +172,8 @@ g.test('set_index_buffer_without_changing_buffer')
renderPass.end();
t.queue.submit([encoder.finish()]);
t.expectTexelViewComparisonIsOkInTexture(
ttu.expectTexelViewComparisonIsOkInTexture(
t,
{ texture: outputTexture },
TexelView.fromTexelsAsBytes('rgba8unorm', coord =>
coord.x === 1 ? kColors[kPositions.length - 1] : kColors[coord.x]
@@ -274,7 +276,8 @@ g.test('set_vertex_buffer_without_changing_buffer')
renderPass.end();
t.queue.submit([encoder.finish()]);
t.expectTexelViewComparisonIsOkInTexture(
ttu.expectTexelViewComparisonIsOkInTexture(
t,
{ texture: outputTexture },
TexelView.fromTexelsAsBytes('rgba8unorm', coord => kColors[coord.x]),
outputTextureSize
@@ -358,7 +361,8 @@ g.test('change_pipeline_before_and_after_vertex_buffer')
t.queue.submit([encoder.finish()]);
t.expectTexelViewComparisonIsOkInTexture(
ttu.expectTexelViewComparisonIsOkInTexture(
t,
{ texture: outputTexture },
TexelView.fromTexelsAsBytes('rgba8unorm', coord =>
coord.x === 1 ? new Uint8Array([0, 0, 0, 255]) : kColors[coord.x]
@@ -536,7 +540,8 @@ g.test('set_vertex_buffer_but_not_used_in_draw')
kColors.subarray(4),
];
t.expectTexelViewComparisonIsOkInTexture(
ttu.expectTexelViewComparisonIsOkInTexture(
t,
{ texture: outputTexture },
TexelView.fromTexelsAsBytes('rgba8unorm', coord => kExpectedColors[coord.x]),
outputTextureSize
@@ -612,7 +617,8 @@ g.test('set_index_buffer_before_non_indexed_draw')
t.queue.submit([encoder.finish()]);
t.expectTexelViewComparisonIsOkInTexture(
ttu.expectTexelViewComparisonIsOkInTexture(
t,
{ texture: outputTexture },
TexelView.fromTexelsAsBytes('rgba8unorm', coord => kColors[coord.x]),
outputTextureSize

11
dom/webgpu/tests/cts/checkout/src/webgpu/api/operation/limits/max_combined_limits.spec.ts
View File

@@ -12,10 +12,11 @@ implementation allows, all of them are useable.
import { makeTestGroup } from '../../../../common/framework/test_group.js';
import { range } from '../../../../common/util/util.js';
import { getColorRenderByteCost } from '../../../format_info.js';
import { AllFeaturesMaxLimitsGPUTest, TextureTestMixin } from '../../../gpu_test.js';
import { AllFeaturesMaxLimitsGPUTest } from '../../../gpu_test.js';
import * as ttu from '../../../texture_test_utils.js';
import { TexelView } from '../../../util/texture/texel_view.js';
export const g = makeTestGroup(TextureTestMixin(AllFeaturesMaxLimitsGPUTest));
export const g = makeTestGroup(AllFeaturesMaxLimitsGPUTest);
g.test('max_storage_buffer_texture_frag_outputs')
.desc(
@@ -198,7 +199,8 @@ ${range(numColorAttachments, i => ` fragOut.f${i} = vec4u(p + ${i} * 3);`).join
});
storageTextures.forEach((texture, i) => {
t.expectTexelViewComparisonIsOkInTexture(
ttu.expectTexelViewComparisonIsOkInTexture(
t,
{ texture },
TexelView.fromTextureDataByReference(
'rgba32uint',
@@ -231,7 +233,8 @@ ${range(numColorAttachments, i => ` fragOut.f${i} = vec4u(p + ${i} * 3);`).join
bytesPerRow = kWidth * 16;
break;
}
t.expectTexelViewComparisonIsOkInTexture(
ttu.expectTexelViewComparisonIsOkInTexture(
t,
{ texture },
TexelView.fromTextureDataByReference(format, expected, {
bytesPerRow,

19
dom/webgpu/tests/cts/checkout/src/webgpu/api/operation/render_pass/clear_value.spec.ts
View File

@@ -13,10 +13,6 @@ import { AllFeaturesMaxLimitsGPUTest } from '../../../gpu_test.js';
export const g = makeTestGroup(AllFeaturesMaxLimitsGPUTest);
g.test('stored')
.desc(`Test render pass clear values are stored at the end of an empty pass.`)
.unimplemented();
g.test('loaded')
.desc(
`Test render pass clear values are visible during the pass by doing some trivial blending
@@ -24,21 +20,6 @@ with the attachment (e.g. add [0,0,0,0] to the color and verify the stored resul
)
.unimplemented();
g.test('srgb')
.desc(
`Test that clear values on '-srgb' type attachments are interpreted as unencoded (linear),
not decoded from srgb to linear.`
)
.unimplemented();
g.test('layout')
.desc(
`Test that bind group layouts of the default pipeline layout are correct by passing various
shaders and then checking their computed bind group layouts are compatible with particular bind
groups.`
)
.unimplemented();
g.test('stencil_clear_value')
.desc(
`Test that when stencilLoadOp is "clear", the stencil aspect should be correctly cleared by

112
dom/webgpu/tests/cts/checkout/src/webgpu/api/operation/render_pass/resolve.spec.ts
View File

@@ -1,20 +1,8 @@
export const description = `API Operation Tests for RenderPass StoreOp.
Tests a render pass with a resolveTarget resolves correctly for many combinations of:
- number of color attachments, some with and some without a resolveTarget
- renderPass storeOp set to {'store', 'discard'}
- resolveTarget mip level {0, >0} (TODO?: different mip level from colorAttachment)
- resolveTarget {2d array layer, TODO: 3d slice} {0, >0} with {2d, TODO: 3d} resolveTarget
(TODO?: different z from colorAttachment)
- TODO: test all renderable color formats
- TODO: test that any not-resolved attachments are rendered to correctly.
- TODO: test different loadOps
- TODO?: resolveTarget mip level {0, >0} (TODO?: different mip level from colorAttachment)
- TODO?: resolveTarget {2d array layer, TODO: 3d slice} {0, >0} with {2d, TODO: 3d} resolveTarget
(different z from colorAttachment)
`;
export const description = `API Operation Tests for multisample resolve in render passes.`;
import { makeTestGroup } from '../../../../common/framework/test_group.js';
import { AllFeaturesMaxLimitsGPUTest, TextureTestMixin } from '../../../gpu_test.js';
import { AllFeaturesMaxLimitsGPUTest } from '../../../gpu_test.js';
import * as ttu from '../../../texture_test_utils.js';
const kSlotsToResolve = [
[0, 2],
@@ -25,11 +13,31 @@ const kSlotsToResolve = [
const kSize = 4;
const kFormat: GPUTextureFormat = 'rgba8unorm';
export const g = makeTestGroup(TextureTestMixin(AllFeaturesMaxLimitsGPUTest));
export const g = makeTestGroup(AllFeaturesMaxLimitsGPUTest);
g.test('render_pass_resolve')
.desc(
`
Test basic render pass resolve behavior for combinations of:
- number of color attachments, some with and some without a resolveTarget
- {a single draw+resolve pass, one draw-store pass and one empty load-resolve pass}
(attempts to test known driver bugs with empty resolve passes)
- in the resolve pass, storeOp set to {'store', 'discard'}
- mip levels {0, 1} and array layers {0, 1}
TODO: cases where color attachment and resolve target don't have the same mip level
- resolveTarget {2d array layer, TODO: 3d slice} {0, >0} with {2d, TODO: 3d} resolveTarget
TODO: cases where color attachment and resolve target don't have the same z (slice or layer)
- TODO: test all renderable color formats
- TODO: test that any not-resolved attachments are rendered to correctly.
- TODO: test different loadOps
- TODO?: resolveTarget mip level {0, >0} (TODO?: different mip level from colorAttachment)
- TODO?: resolveTarget {2d array layer, TODO: 3d slice} {0, >0} with {2d, TODO: 3d} resolveTarget
(different z from colorAttachment)
`
)
.params(u =>
u
.combine('separateResolvePass', [false, true])
.combine('storeOperation', ['discard', 'store'] as const)
.beginSubcases()
.combine('numColorAttachments', [2, 4] as const)
@@ -92,61 +100,61 @@ g.test('render_pass_resolve')
});
const resolveTargets: GPUTexture[] = [];
const renderPassColorAttachments: GPURenderPassColorAttachment[] = [];
const drawPassAttachments: GPURenderPassColorAttachment[] = [];
const resolvePassAttachments: GPURenderPassColorAttachment[] = [];
// The resolve target must be the same size as the color attachment. If we're resolving to mip
// level 1, the resolve target base mip level should be 2x the color attachment size.
const kResolveTargetSize = kSize << t.params.resolveTargetBaseMipLevel;
for (let i = 0; i < t.params.numColorAttachments; i++) {
const colorAttachment = t.createTextureTracked({
const colorAttachment = t
.createTextureTracked({
format: kFormat,
size: { width: kSize, height: kSize, depthOrArrayLayers: 1 },
size: [kSize, kSize, 1],
sampleCount: 4,
mipLevelCount: 1,
usage:
GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
})
.createView();
let resolveTarget: GPUTextureView | undefined;
if (t.params.slotsToResolve.includes(i)) {
const colorAttachment = t.createTextureTracked({
const resolveTargetTexture = t.createTextureTracked({
format: kFormat,
size: { width: kSize, height: kSize, depthOrArrayLayers: 1 },
sampleCount: 4,
mipLevelCount: 1,
usage:
GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
const resolveTarget = t.createTextureTracked({
format: kFormat,
size: {
width: kResolveTargetSize,
height: kResolveTargetSize,
depthOrArrayLayers: t.params.resolveTargetBaseArrayLayer + 1,
},
size: [kResolveTargetSize, kResolveTargetSize, t.params.resolveTargetBaseArrayLayer + 1],
sampleCount: 1,
mipLevelCount: t.params.resolveTargetBaseMipLevel + 1,
usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
resolveTargets.push(resolveTargetTexture);
resolveTarget = resolveTargetTexture.createView({
baseMipLevel: t.params.resolveTargetBaseMipLevel,
baseArrayLayer: t.params.resolveTargetBaseArrayLayer,
});
}
// Clear to black for the load operation. After the draw, the top left half of the attachment
// will be white and the bottom right half will be black.
renderPassColorAttachments.push({
view: colorAttachment.createView(),
if (t.params.separateResolvePass) {
drawPassAttachments.push({
view: colorAttachment,
clearValue: { r: 0.0, g: 0.0, b: 0.0, a: 0.0 },
loadOp: 'clear',
storeOp: t.params.storeOperation,
resolveTarget: resolveTarget.createView({
baseMipLevel: t.params.resolveTargetBaseMipLevel,
baseArrayLayer: t.params.resolveTargetBaseArrayLayer,
}),
storeOp: 'store',
});
resolvePassAttachments.push({
view: colorAttachment,
resolveTarget,
loadOp: 'load',
storeOp: t.params.storeOperation,
});
resolveTargets.push(resolveTarget);
} else {
renderPassColorAttachments.push({
view: colorAttachment.createView(),
drawPassAttachments.push({
view: colorAttachment,
resolveTarget,
clearValue: { r: 0.0, g: 0.0, b: 0.0, a: 0.0 },
loadOp: 'clear',
storeOp: t.params.storeOperation,
@@ -155,20 +163,22 @@ g.test('render_pass_resolve')
}
const encoder = t.device.createCommandEncoder();
const pass = encoder.beginRenderPass({
colorAttachments: renderPassColorAttachments,
});
const pass = encoder.beginRenderPass({ colorAttachments: drawPassAttachments });
pass.setPipeline(pipeline);
pass.draw(3);
pass.end();
if (t.params.separateResolvePass) {
const pass = encoder.beginRenderPass({ colorAttachments: resolvePassAttachments });
pass.end();
}
t.device.queue.submit([encoder.finish()]);
// Verify the resolve targets contain the correct values. Note that we use z to specify the
// array layer from which to pull the pixels for testing.
const z = t.params.resolveTargetBaseArrayLayer;
for (const resolveTarget of resolveTargets) {
t.expectSinglePixelComparisonsAreOkInTexture(
ttu.expectSinglePixelComparisonsAreOkInTexture(
t,
{ texture: resolveTarget, mipLevel: t.params.resolveTargetBaseMipLevel },
[
// Top left pixel should be {1.0, 1.0, 1.0, 1.0}.

74
dom/webgpu/tests/cts/checkout/src/webgpu/api/operation/render_pass/storeOp.spec.ts
View File

@@ -28,14 +28,22 @@ export const description = `API Operation Tests for RenderPass StoreOp.
TODO: test with more interesting loadOp values`;
import { makeTestGroup } from '../../../../common/framework/test_group.js';
import { assert } from '../../../../common/util/util.js';
import {
EncodableTextureFormat,
isDepthTextureFormat,
isSintOrUintFormat,
isStencilTextureFormat,
kPossibleColorRenderableTextureFormats,
kSizedDepthStencilFormats,
} from '../../../format_info.js';
import { AllFeaturesMaxLimitsGPUTest } from '../../../gpu_test.js';
import { PerTexelComponent } from '../../../util/texture/texel_data.js';
import * as ttu from '../../../texture_test_utils.js';
import {
kTexelRepresentationInfo,
PerTexelComponent,
TexelComponent,
} from '../../../util/texture/texel_data.js';
// Test with a zero and non-zero mip.
const kMipLevel: number[] = [0, 1];
@@ -150,35 +158,66 @@ g.test('render_pass_store_op,color_attachment_only')
.combine('arrayLayer', kArrayLayers)
)
.fn(t => {
t.skipIfTextureFormatNotSupported(t.params.colorFormat);
t.skipIfTextureFormatNotUsableAsRenderAttachment(t.params.colorFormat);
const { colorFormat, storeOperation, mipLevel, arrayLayer } = t.params;
t.skipIfTextureFormatNotSupported(colorFormat);
t.skipIfTextureFormatNotUsableAsRenderAttachment(colorFormat);
const colorAttachment = t.createTextureTracked({
format: t.params.colorFormat,
size: { width: kWidth, height: kHeight, depthOrArrayLayers: t.params.arrayLayer + 1 },
format: colorFormat,
size: { width: kWidth, height: kHeight, depthOrArrayLayers: arrayLayer + 1 },
mipLevelCount: kMipLevelCount,
usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
});
const colorViewDesc: GPUTextureViewDescriptor = {
baseArrayLayer: t.params.arrayLayer,
baseMipLevel: t.params.mipLevel,
baseArrayLayer: arrayLayer,
baseMipLevel: mipLevel,
mipLevelCount: 1,
arrayLayerCount: 1,
};
const colorAttachmentView = colorAttachment.createView(colorViewDesc);
// Color load operation will clear to {1.0, 0.0, 0.0, 1.0}.
const components = new Set(
kTexelRepresentationInfo[colorFormat as EncodableTextureFormat]?.componentOrder ?? []
);
assert(components.size > 0);
// Note: for unorm/float values we specifically want values
// that will generate failure if srgb remapping is applied so
// we can't choose 0 or 1 for R, G, or B
const missingValue = { R: 0, G: 0, B: 0, A: 1 };
const [baseValue, maxDiff] = isSintOrUintFormat(colorFormat)
? [{ R: 12, G: 34, B: 56, A: 3 }, 0]
: [{ R: 0.8, G: 0.75, B: 0.5, A: 1.0 }, 2 / 255];
const kRGBAComponents = [
TexelComponent.R,
TexelComponent.G,
TexelComponent.B,
TexelComponent.A,
] as const;
const clearValueAsComponents = Object.fromEntries(
kRGBAComponents.map(component => [
component,
components.has(component) ? baseValue[component] : missingValue[component],
])
);
const clearValue = Object.fromEntries(
Object.entries(clearValueAsComponents).map(([k, v]) => [k.toLowerCase(), v])
) as unknown as GPUColorDict;
t.debug(`clearValue: ${JSON.stringify(clearValue)}`);
// Color store operation is determined by the test params.
const encoder = t.device.createCommandEncoder();
const pass = encoder.beginRenderPass({
colorAttachments: [
{
view: colorAttachmentView,
clearValue: { r: 1.0, g: 0.0, b: 0.0, a: 1.0 },
clearValue,
loadOp: 'clear',
storeOp: t.params.storeOperation,
storeOp: storeOperation,
},
],
});
@@ -187,19 +226,20 @@ g.test('render_pass_store_op,color_attachment_only')
// Check that the correct store operation occurred.
let expectedValue: PerTexelComponent<number> = {};
if (t.params.storeOperation === 'discard') {
if (storeOperation === 'discard') {
// If colorStoreOp was clear, the texture should now contain {0.0, 0.0, 0.0, 0.0}.
expectedValue = { R: 0.0, G: 0.0, B: 0.0, A: 0.0 };
} else if (t.params.storeOperation === 'store') {
// If colorStoreOP was store, the texture should still contain {1.0, 0.0, 0.0, 1.0}.
expectedValue = { R: 1.0, G: 0.0, B: 0.0, A: 1.0 };
} else if (storeOperation === 'store') {
// If colorStoreOP was store, the texture should still contain
expectedValue = clearValueAsComponents;
}
t.expectSingleColor(colorAttachment, t.params.colorFormat, {
ttu.expectSingleColorWithTolerance(t, colorAttachment, colorFormat, {
size: [kHeight, kWidth, 1],
slice: t.params.arrayLayer,
slice: arrayLayer,
exp: expectedValue,
layout: { mipLevel: t.params.mipLevel },
layout: { mipLevel },
maxFractionalDiff: maxDiff,
});
});

7
dom/webgpu/tests/cts/checkout/src/webgpu/api/operation/render_pipeline/culling_tests.spec.ts
View File

@@ -6,7 +6,8 @@ Test all culling combinations of GPUFrontFace and GPUCullMode show the correct o
import { makeTestGroup } from '../../../../common/framework/test_group.js';
import { isStencilTextureFormat, SizedTextureFormat } from '../../../format_info.js';
import { AllFeaturesMaxLimitsGPUTest, TextureTestMixin } from '../../../gpu_test.js';
import { AllFeaturesMaxLimitsGPUTest } from '../../../gpu_test.js';
import * as ttu from '../../../texture_test_utils.js';
function faceIsCulled(face: 'cw' | 'ccw', frontFace: GPUFrontFace, cullMode: GPUCullMode): boolean {
return cullMode !== 'none' && (frontFace === face) === (cullMode === 'front');
@@ -24,13 +25,13 @@ function faceColor(face: 'cw' | 'ccw', frontFace: GPUFrontFace, cullMode: GPUCul
}
}
class CullingTest extends TextureTestMixin(AllFeaturesMaxLimitsGPUTest) {
class CullingTest extends AllFeaturesMaxLimitsGPUTest {
checkCornerPixels(
texture: GPUTexture,
expectedTopLeftColor: Uint8Array,
expectedBottomRightColor: Uint8Array
) {
this.expectSinglePixelComparisonsAreOkInTexture({ texture }, [
ttu.expectSinglePixelComparisonsAreOkInTexture(this, { texture }, [
{ coord: { x: 0, y: 0 }, exp: expectedTopLeftColor },
{ coord: { x: texture.width - 1, y: texture.height - 1 }, exp: expectedBottomRightColor },
]);

7
dom/webgpu/tests/cts/checkout/src/webgpu/api/operation/render_pipeline/pipeline_output_targets.spec.ts
View File

@@ -11,7 +11,8 @@ import {
isSintOrUintFormat,
kPossibleColorRenderableTextureFormats,
} from '../../../format_info.js';
import { AllFeaturesMaxLimitsGPUTest, TextureTestMixin } from '../../../gpu_test.js';
import { AllFeaturesMaxLimitsGPUTest } from '../../../gpu_test.js';
import * as ttu from '../../../texture_test_utils.js';
import { getFragmentShaderCodeWithOutput, getPlainTypeInfo } from '../../../util/shader.js';
import { kTexelRepresentationInfo } from '../../../util/texture/texel_data.js';
@@ -27,7 +28,7 @@ const kVertexShader = `
}
`;
export const g = makeTestGroup(TextureTestMixin(AllFeaturesMaxLimitsGPUTest));
export const g = makeTestGroup(AllFeaturesMaxLimitsGPUTest);
// Values to write into each attachment
// We make values different for each attachment index and each channel
@@ -139,7 +140,7 @@ g.test('color,attachments')
if (i === emptyAttachmentId) {
continue;
}
t.expectSinglePixelComparisonsAreOkInTexture({ texture: renderTargets[i] }, [
ttu.expectSinglePixelComparisonsAreOkInTexture(t, { texture: renderTargets[i] }, [
{ coord: { x: 0, y: 0 }, exp: writeValues[i] },
]);
}

11
dom/webgpu/tests/cts/checkout/src/webgpu/api/operation/render_pipeline/primitive_topology.spec.ts
View File

@@ -56,7 +56,8 @@ Test locations are framebuffer coordinates:
`;
import { makeTestGroup } from '../../../../common/framework/test_group.js';
import { AllFeaturesMaxLimitsGPUTest, TextureTestMixin } from '../../../gpu_test.js';
import { AllFeaturesMaxLimitsGPUTest } from '../../../gpu_test.js';
import * as ttu from '../../../texture_test_utils.js';
import { PerPixelComparison } from '../../../util/texture/texture_ok.js';
const kRTSize: number = 56;
@@ -279,7 +280,7 @@ function generateVertexBuffer(vertexLocations: Point2D[]): Float32Array {
}
const kDefaultDrawCount = 6;
class PrimitiveTopologyTest extends TextureTestMixin(AllFeaturesMaxLimitsGPUTest) {
class PrimitiveTopologyTest extends AllFeaturesMaxLimitsGPUTest {
makeAttachmentTexture(): GPUTexture {
return this.createTextureTracked({
format: kColorFormat,
@@ -410,7 +411,11 @@ class PrimitiveTopologyTest extends TextureTestMixin(AllFeaturesMaxLimitsGPUTest
renderPass.end();
this.device.queue.submit([encoder.finish()]);
this.expectSinglePixelComparisonsAreOkInTexture({ texture: colorAttachment }, testLocations);
ttu.expectSinglePixelComparisonsAreOkInTexture(
this,
{ texture: colorAttachment },
testLocations
);
}
}

8
dom/webgpu/tests/cts/checkout/src/webgpu/api/operation/render_pipeline/sample_mask.spec.ts
View File

@@ -19,7 +19,8 @@ Details could be found at: https://github.com/gpuweb/cts/issues/2201
import { makeTestGroup } from '../../../../common/framework/test_group.js';
import { assert, range } from '../../../../common/util/util.js';
import { AllFeaturesMaxLimitsGPUTest, TextureTestMixin } from '../../../gpu_test.js';
import { AllFeaturesMaxLimitsGPUTest } from '../../../gpu_test.js';
import * as ttu from '../../../texture_test_utils.js';
import { checkElementsPassPredicate, checkElementsEqual } from '../../../util/check_contents.js';
import { Type } from '../../../util/conversion.js';
import { TexelView } from '../../../util/texture/texel_view.js';
@@ -263,7 +264,7 @@ struct FragmentOutput2 {
}
`;
class F extends TextureTestMixin(AllFeaturesMaxLimitsGPUTest) {
class F extends AllFeaturesMaxLimitsGPUTest {
private sampleTexture: GPUTexture | undefined;
private sampler: GPUSampler | undefined;
@@ -278,7 +279,8 @@ class F extends TextureTestMixin(AllFeaturesMaxLimitsGPUTest) {
// texel 2 - Blue
// texel 3 - Yellow
const kSampleTextureSize = 2;
this.sampleTexture = this.createTextureFromTexelView(
this.sampleTexture = ttu.createTextureFromTexelView(
this,
TexelView.fromTexelsAsBytes(format, coord => {
const id = coord.x + coord.y * kSampleTextureSize;
return kColors[id];

32
dom/webgpu/tests/cts/checkout/src/webgpu/api/operation/rendering/color_target_state.spec.ts
View File

@@ -19,7 +19,8 @@ import {
EncodableTextureFormat,
kPossibleColorRenderableTextureFormats,
} from '../../../format_info.js';
import { AllFeaturesMaxLimitsGPUTest, TextureTestMixin } from '../../../gpu_test.js';
import { AllFeaturesMaxLimitsGPUTest } from '../../../gpu_test.js';
import * as ttu from '../../../texture_test_utils.js';
import { clamp } from '../../../util/math.js';
import { TexelView } from '../../../util/texture/texel_view.js';
@@ -76,7 +77,7 @@ class BlendingTest extends AllFeaturesMaxLimitsGPUTest {
}
}
export const g = makeTestGroup(TextureTestMixin(BlendingTest));
export const g = makeTestGroup(BlendingTest);
function mapColor(
col: GPUColorDict,
@@ -367,7 +368,8 @@ struct FragOutput {
t.device.queue.submit([commandEncoder.finish()]);
t.expectSinglePixelComparisonsAreOkInTexture(
ttu.expectSinglePixelComparisonsAreOkInTexture(
t,
{ texture: renderTarget },
[
{
@@ -457,7 +459,12 @@ g.test('blending,formats')
format as EncodableTextureFormat,
_coords => expColor
);
t.expectTexelViewComparisonIsOkInTexture({ texture: renderTarget }, expTexelView, [1, 1, 1]);
ttu.expectTexelViewComparisonIsOkInTexture(
t,
{ texture: renderTarget },
expTexelView,
[1, 1, 1]
);
});
g.test('blend_constant,initial')
@@ -505,7 +512,7 @@ g.test('blend_constant,initial')
// a white color buffer data.
const expColor = { R: 0, G: 0, B: 0, A: 0 };
const expTexelView = TexelView.fromTexelsAsColors(format, _coords => expColor);
t.expectTexelViewComparisonIsOkInTexture({ texture: renderTarget }, expTexelView, [
ttu.expectTexelViewComparisonIsOkInTexture(t, { texture: renderTarget }, expTexelView, [
kSize,
kSize,
]);
@@ -564,7 +571,7 @@ g.test('blend_constant,setting')
const expColor = { R: r, G: g, B: b, A: a };
const expTexelView = TexelView.fromTexelsAsColors(format, _coords => expColor);
t.expectTexelViewComparisonIsOkInTexture({ texture: renderTarget }, expTexelView, [
ttu.expectTexelViewComparisonIsOkInTexture(t, { texture: renderTarget }, expTexelView, [
kSize,
kSize,
]);
@@ -637,7 +644,7 @@ g.test('blend_constant,not_inherited')
const expColor = { R: 0, G: 0, B: 0, A: 0 };
const expTexelView = TexelView.fromTexelsAsColors(format, _coords => expColor);
t.expectTexelViewComparisonIsOkInTexture({ texture: renderTarget }, expTexelView, [
ttu.expectTexelViewComparisonIsOkInTexture(t, { texture: renderTarget }, expTexelView, [
kSize,
kSize,
]);
@@ -718,7 +725,7 @@ g.test('color_write_mask,channel_work')
const expColor = { R: r, G: g, B: b, A: a };
const expTexelView = TexelView.fromTexelsAsColors(format, _coords => expColor);
t.expectTexelViewComparisonIsOkInTexture({ texture: renderTarget }, expTexelView, [
ttu.expectTexelViewComparisonIsOkInTexture(t, { texture: renderTarget }, expTexelView, [
kSize,
kSize,
]);
@@ -776,7 +783,7 @@ g.test('color_write_mask,blending_disabled')
const expColor = { R: 1, G: 0, B: 0, A: 0 };
const expTexelView = TexelView.fromTexelsAsColors(format, _coords => expColor);
t.expectTexelViewComparisonIsOkInTexture({ texture: renderTarget }, expTexelView, [
ttu.expectTexelViewComparisonIsOkInTexture(t, { texture: renderTarget }, expTexelView, [
kSize,
kSize,
]);
@@ -873,5 +880,10 @@ g.test('blending,clamping')
const expColor = { R: expValue, G: expValue, B: expValue, A: expValue };
const expTexelView = TexelView.fromTexelsAsColors(format, _coords => expColor);
t.expectTexelViewComparisonIsOkInTexture({ texture: renderTarget }, expTexelView, [1, 1, 1]);
ttu.expectTexelViewComparisonIsOkInTexture(
t,
{ texture: renderTarget },
expTexelView,
[1, 1, 1]
);
});

16
dom/webgpu/tests/cts/checkout/src/webgpu/api/operation/rendering/depth.spec.ts
View File

@@ -5,7 +5,8 @@ Test related to depth buffer, depth op, compare func, etc.
import { makeTestGroup } from '../../../../common/framework/test_group.js';
import { TypedArrayBufferView } from '../../../../common/util/util.js';
import { isStencilTextureFormat, kDepthTextureFormats } from '../../../format_info.js';
import { AllFeaturesMaxLimitsGPUTest, TextureTestMixin } from '../../../gpu_test.js';
import { AllFeaturesMaxLimitsGPUTest } from '../../../gpu_test.js';
import * as ttu from '../../../texture_test_utils.js';
import { TexelView } from '../../../util/texture/texel_view.js';
const backgroundColor = [0x00, 0x00, 0x00, 0xff];
@@ -21,7 +22,7 @@ type TestStates = {
depth: number;
};
class DepthTest extends TextureTestMixin(AllFeaturesMaxLimitsGPUTest) {
class DepthTest extends AllFeaturesMaxLimitsGPUTest {
runDepthStateTest(testStates: TestStates[], expectedColor: Float32Array) {
const renderTargetFormat = 'rgba8unorm';
@@ -82,7 +83,12 @@ class DepthTest extends TextureTestMixin(AllFeaturesMaxLimitsGPUTest) {
};
const expTexelView = TexelView.fromTexelsAsColors(renderTargetFormat, _coords => expColor);
this.expectTexelViewComparisonIsOkInTexture({ texture: renderTarget }, expTexelView, [1, 1]);
ttu.expectTexelViewComparisonIsOkInTexture(
this,
{ texture: renderTarget },
expTexelView,
[1, 1]
);
}
createRenderPipelineForTest(
@@ -411,7 +417,7 @@ g.test('depth_compare_func')
pass.end();
t.device.queue.submit([encoder.finish()]);
t.expectSinglePixelComparisonsAreOkInTexture({ texture: colorAttachment }, [
ttu.expectSinglePixelComparisonsAreOkInTexture(t, { texture: colorAttachment }, [
{
coord: { x: 0, y: 0 },
exp: new Uint8Array(_expected),
@@ -519,7 +525,7 @@ g.test('reverse_depth')
pass.end();
t.device.queue.submit([encoder.finish()]);
t.expectSinglePixelComparisonsAreOkInTexture({ texture: colorAttachment }, [
ttu.expectSinglePixelComparisonsAreOkInTexture(t, { texture: colorAttachment }, [
{
coord: { x: 0, y: 0 },
exp: new Uint8Array(

19
dom/webgpu/tests/cts/checkout/src/webgpu/api/operation/rendering/depth_bias.spec.ts
View File

@@ -11,7 +11,8 @@ import {
isDepthTextureFormat,
isStencilTextureFormat,
} from '../../../format_info.js';
import { AllFeaturesMaxLimitsGPUTest, TextureTestMixin } from '../../../gpu_test.js';
import { AllFeaturesMaxLimitsGPUTest } from '../../../gpu_test.js';
import * as ttu from '../../../texture_test_utils.js';
import { TexelView } from '../../../util/texture/texel_view.js';
enum QuadAngle {
@@ -30,7 +31,7 @@ enum QuadAngle {
// depthBias = 0.25 / (2 ** (-2 - 23)) = 8388608.
const kPointTwoFiveBiasForPointTwoFiveZOnFloat = 8388608;
class DepthBiasTest extends TextureTestMixin(AllFeaturesMaxLimitsGPUTest) {
class DepthBiasTest extends AllFeaturesMaxLimitsGPUTest {
runDepthBiasTestInternal(
depthFormat: DepthStencilFormat,
{
@@ -172,7 +173,12 @@ class DepthBiasTest extends TextureTestMixin(AllFeaturesMaxLimitsGPUTest) {
const expColor = { Depth: _expectedDepth };
const expTexelView = TexelView.fromTexelsAsColors(depthFormat, _coords => expColor);
this.expectTexelViewComparisonIsOkInTexture({ texture: depthTexture }, expTexelView, [1, 1]);
ttu.expectTexelViewComparisonIsOkInTexture(
this,
{ texture: depthTexture },
expTexelView,
[1, 1]
);
}
runDepthBiasTestFor24BitFormat(
@@ -207,7 +213,12 @@ class DepthBiasTest extends TextureTestMixin(AllFeaturesMaxLimitsGPUTest) {
A: _expectedColor[3],
};
const expTexelView = TexelView.fromTexelsAsColors(renderTargetFormat, _coords => expColor);
this.expectTexelViewComparisonIsOkInTexture({ texture: renderTarget }, expTexelView, [1, 1]);
ttu.expectTexelViewComparisonIsOkInTexture(
this,
{ texture: renderTarget },
expTexelView,
[1, 1]
);
}
createRenderPipelineForTest(

11
dom/webgpu/tests/cts/checkout/src/webgpu/api/operation/rendering/draw.spec.ts
View File

@@ -11,10 +11,11 @@ import {
TypedArrayBufferView,
TypedArrayBufferViewConstructor,
} from '../../../../common/util/util.js';
import { AllFeaturesMaxLimitsGPUTest, TextureTestMixin } from '../../../gpu_test.js';
import { AllFeaturesMaxLimitsGPUTest } from '../../../gpu_test.js';
import * as ttu from '../../../texture_test_utils.js';
import { PerPixelComparison } from '../../../util/texture/texture_ok.js';
class DrawTest extends TextureTestMixin(AllFeaturesMaxLimitsGPUTest) {
class DrawTest extends AllFeaturesMaxLimitsGPUTest {
checkTriangleDraw(opts: {
firstIndex: number | undefined;
count: number;
@@ -314,7 +315,11 @@ struct Output {
});
}
}
this.expectSinglePixelComparisonsAreOkInTexture({ texture: renderTarget }, pixelComparisons);
ttu.expectSinglePixelComparisonsAreOkInTexture(
this,
{ texture: renderTarget },
pixelComparisons
);
}
}

7
dom/webgpu/tests/cts/checkout/src/webgpu/api/operation/rendering/indirect_draw.spec.ts
View File

@@ -7,7 +7,8 @@ import {
kDrawIndirectParametersSize,
kDrawIndexedIndirectParametersSize,
} from '../../../capability_info.js';
import { AllFeaturesMaxLimitsGPUTest, TextureTestMixin } from '../../../gpu_test.js';
import { AllFeaturesMaxLimitsGPUTest } from '../../../gpu_test.js';
import * as ttu from '../../../texture_test_utils.js';
const filled = new Uint8Array([0, 255, 0, 255]);
const notFilled = new Uint8Array([0, 0, 0, 0]);
@@ -124,7 +125,7 @@ class F extends AllFeaturesMaxLimitsGPUTest {
}
}
export const g = makeTestGroup(TextureTestMixin(F));
export const g = makeTestGroup(F);
g.test('basics')
.desc(
@@ -233,7 +234,7 @@ Params:
renderPass.end();
t.queue.submit([commandEncoder.finish()]);
t.expectSinglePixelComparisonsAreOkInTexture({ texture: renderTarget }, [
ttu.expectSinglePixelComparisonsAreOkInTexture(t, { texture: renderTarget }, [
// The bottom left area is filled
{ coord: { x: 0, y: 1 }, exp: filled },
// The top right area is not filled

12
dom/webgpu/tests/cts/checkout/src/webgpu/api/operation/rendering/stencil.spec.ts
View File

@@ -16,7 +16,8 @@ import {
kDepthStencilFormats,
depthStencilFormatAspectSize,
} from '../../../format_info.js';
import { AllFeaturesMaxLimitsGPUTest, TextureTestMixin } from '../../../gpu_test.js';
import { AllFeaturesMaxLimitsGPUTest } from '../../../gpu_test.js';
import * as ttu from '../../../texture_test_utils.js';
import { align } from '../../../util/math.js';
import { DataArrayGenerator } from '../../../util/texture/data_generation.js';
import { dataBytesForCopyOrFail, getTextureCopyLayout } from '../../../util/texture/layout.js';
@@ -32,7 +33,7 @@ type TestStates = {
stencil: number | undefined;
};
class StencilTest extends TextureTestMixin(AllFeaturesMaxLimitsGPUTest) {
class StencilTest extends AllFeaturesMaxLimitsGPUTest {
checkStencilOperation(
depthStencilFormat: DepthStencilFormat,
testStencilState: GPUStencilFaceState,
@@ -218,7 +219,12 @@ class StencilTest extends TextureTestMixin(AllFeaturesMaxLimitsGPUTest) {
A: expectedColor[3],
};
const expTexelView = TexelView.fromTexelsAsColors(renderTargetFormat, _coords => expColor);
this.expectTexelViewComparisonIsOkInTexture({ texture: renderTarget }, expTexelView, [1, 1]);
ttu.expectTexelViewComparisonIsOkInTexture(
this,
{ texture: renderTarget },
expTexelView,
[1, 1]
);
}
createRenderPipelineForTest(depthStencil: GPUDepthStencilState): GPURenderPipeline {

14
dom/webgpu/tests/cts/checkout/src/webgpu/api/operation/sampling/anisotropy.spec.ts
View File

@@ -12,7 +12,8 @@ things. If there are no guarantees we can issue warnings instead of failures. Id
import { makeTestGroup } from '../../../../common/framework/test_group.js';
import { assert } from '../../../../common/util/util.js';
import { AllFeaturesMaxLimitsGPUTest, TextureTestMixin } from '../../../gpu_test.js';
import { AllFeaturesMaxLimitsGPUTest } from '../../../gpu_test.js';
import * as ttu from '../../../texture_test_utils.js';
import { checkElementsEqual } from '../../../util/check_contents.js';
import { TexelView } from '../../../util/texture/texel_view.js';
import { PerPixelComparison } from '../../../util/texture/texture_ok.js';
@@ -161,7 +162,7 @@ class SamplerAnisotropicFilteringSlantedPlaneTest extends AllFeaturesMaxLimitsGP
}
}
export const g = makeTestGroup(TextureTestMixin(SamplerAnisotropicFilteringSlantedPlaneTest));
export const g = makeTestGroup(SamplerAnisotropicFilteringSlantedPlaneTest);
g.test('anisotropic_filter_checkerboard')
.desc(
@@ -286,7 +287,8 @@ g.test('anisotropic_filter_mipmap_color')
},
])
.fn(t => {
const texture = t.createTextureFromTexelViewsMultipleMipmaps(
const texture = ttu.createTextureFromTexelViewsMultipleMipmaps(
t,
colors.map(value => TexelView.fromTexelsAsBytes(kTextureFormat, _coords => value)),
{ size: [4, 4, 1], usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING }
);
@@ -321,5 +323,9 @@ g.test('anisotropic_filter_mipmap_color')
);
}
}
t.expectSinglePixelComparisonsAreOkInTexture({ texture: colorAttachment }, pixelComparisons);
ttu.expectSinglePixelComparisonsAreOkInTexture(
t,
{ texture: colorAttachment },
pixelComparisons
);
});

25
dom/webgpu/tests/cts/checkout/src/webgpu/api/operation/sampling/filter_mode.spec.ts
View File

@@ -14,7 +14,8 @@ import {
isTextureFormatColorRenderable,
kPossibleColorRenderableTextureFormats,
} from '../../../format_info.js';
import { AllFeaturesMaxLimitsGPUTest, TextureTestMixin } from '../../../gpu_test.js';
import { AllFeaturesMaxLimitsGPUTest } from '../../../gpu_test.js';
import * as ttu from '../../../texture_test_utils.js';
import { getTextureCopyLayout } from '../../../util/texture/layout.js';
import { TexelView } from '../../../util/texture/texel_view.js';
@@ -38,7 +39,7 @@ const kPossiblyRenderablePossiblyFilterableColorTextureFormats =
getTextureFormatType(format) === 'unfilterable-float'
);
class FilterModeTest extends TextureTestMixin(AllFeaturesMaxLimitsGPUTest) {
class FilterModeTest extends AllFeaturesMaxLimitsGPUTest {
runFilterRenderPipeline(
sampler: GPUSampler,
module: GPUShaderModule,
@@ -53,7 +54,8 @@ class FilterModeTest extends TextureTestMixin(AllFeaturesMaxLimitsGPUTest) {
// to verify the result, which is always renderable.
renderTargetFormat = 'rgba32float';
}
const sampleTexture = this.createTextureFromTexelView(
const sampleTexture = ttu.createTextureFromTexelView(
this,
TexelView.fromTexelsAsColors(format, coord => {
const id = coord.x + coord.y * kCheckerTextureSize;
return kCheckerTextureData[id];
@@ -554,7 +556,8 @@ g.test('magFilter,nearest')
vertexCount,
instanceCount
);
t.expectTexelViewComparisonIsOkInTexture(
ttu.expectTexelViewComparisonIsOkInTexture(
t,
{ texture: render.texture },
expectedColors(render.format, 'nearest', addressModeU, addressModeV),
kNearestRenderDim
@@ -669,7 +672,8 @@ g.test('magFilter,linear')
vertexCount,
instanceCount
);
t.expectTexelViewComparisonIsOkInTexture(
ttu.expectTexelViewComparisonIsOkInTexture(
t,
{ texture: render.texture },
expectedColors(render.format, 'linear', addressModeU, addressModeV),
kLinearRenderDim
@@ -796,7 +800,8 @@ g.test('minFilter,nearest')
vertexCount,
instanceCount
);
t.expectTexelViewComparisonIsOkInTexture(
ttu.expectTexelViewComparisonIsOkInTexture(
t,
{ texture: render.texture },
expectedColors(render.format, 'nearest', addressModeU, addressModeV),
kNearestRenderDim
@@ -921,7 +926,8 @@ g.test('minFilter,linear')
vertexCount,
instanceCount
);
t.expectTexelViewComparisonIsOkInTexture(
ttu.expectTexelViewComparisonIsOkInTexture(
t,
{ texture: render.texture },
expectedColors(render.format, 'linear', addressModeU, addressModeV),
kLinearRenderDim
@@ -964,7 +970,8 @@ g.test('mipmapFilter')
const sampler = t.device.createSampler({
mipmapFilter: filterMode,
});
const sampleTexture = t.createTextureFromTexelViewsMultipleMipmaps(
const sampleTexture = ttu.createTextureFromTexelViewsMultipleMipmaps(
t,
[
TexelView.fromTexelsAsColors(format, () => {
return { R: 0.0, G: 0.0, B: 0.0, A: 1.0 };
@@ -1058,7 +1065,7 @@ g.test('mipmapFilter')
// Since mipmap filtering varies across different backends, we verify that the result exhibits
// filtered characteristics without strict value equalities via copies to a buffer.
const buffer = t.copyWholeTextureToNewBufferSimple(renderTexture, 0);
const buffer = ttu.copyWholeTextureToNewBufferSimple(t, renderTexture, 0);
t.expectGPUBufferValuesPassCheck(
buffer,
actual => {

7
dom/webgpu/tests/cts/checkout/src/webgpu/api/operation/sampling/sampler_texture.spec.ts
View File

@@ -7,10 +7,11 @@ Tests samplers with textures.
import { makeTestGroup } from '../../../../common/framework/test_group.js';
import { assert, range } from '../../../../common/util/util.js';
import { AllFeaturesMaxLimitsGPUTest, TextureTestMixin } from '../../../gpu_test.js';
import { AllFeaturesMaxLimitsGPUTest } from '../../../gpu_test.js';
import * as ttu from '../../../texture_test_utils.js';
import { TexelView } from '../../../util/texture/texel_view.js';
export const g = makeTestGroup(TextureTestMixin(AllFeaturesMaxLimitsGPUTest));
export const g = makeTestGroup(AllFeaturesMaxLimitsGPUTest);
g.test('sample_texture_combos')
.desc(
@@ -333,7 +334,7 @@ ${declarationLines.join('\n')}
);
const size = [numAcross, 2];
t.expectTexelViewComparisonIsOkInTexture({ texture: renderTarget }, expTexelView, size);
ttu.expectTexelViewComparisonIsOkInTexture(t, { texture: renderTarget }, expTexelView, size);
textures.forEach(texture => texture.destroy());
});

18
dom/webgpu/tests/cts/checkout/src/webgpu/api/operation/texture_view/format_reinterpretation.spec.ts
View File

@@ -11,10 +11,11 @@ import {
kDifferentBaseFormatRegularTextureFormats,
RegularTextureFormat,
} from '../../../format_info.js';
import { AllFeaturesMaxLimitsGPUTest, TextureTestMixin } from '../../../gpu_test.js';
import { AllFeaturesMaxLimitsGPUTest } from '../../../gpu_test.js';
import * as ttu from '../../../texture_test_utils.js';
import { TexelView } from '../../../util/texture/texel_view.js';
export const g = makeTestGroup(TextureTestMixin(AllFeaturesMaxLimitsGPUTest));
export const g = makeTestGroup(AllFeaturesMaxLimitsGPUTest);
const kColors = [
{ R: 1.0, G: 0.0, B: 0.0, A: 0.8 },
@@ -119,7 +120,7 @@ g.test('texture_binding')
const inputTexelView = makeInputTexelView(format);
// Create the initial texture with the contents of the input texel view.
const texture = t.createTextureFromTexelView(inputTexelView, {
const texture = ttu.createTextureFromTexelView(t, inputTexelView, {
size: [kTextureSize, kTextureSize],
usage: GPUTextureUsage.TEXTURE_BINDING,
viewFormats: [viewFormat],
@@ -181,7 +182,8 @@ g.test('texture_binding')
pass.end();
t.device.queue.submit([commandEncoder.finish()]);
t.expectTexelViewComparisonIsOkInTexture(
ttu.expectTexelViewComparisonIsOkInTexture(
t,
{ texture: outputTexture },
TexelView.fromTexelsAsColors('rgba8unorm', reinterpretedTexelView.color, {
clampToFormatRange: true,
@@ -245,7 +247,7 @@ in view format and match in base format.`
// Create the sample source with the contents of the input texel view.
// We will sample this texture into |renderTexture|. It uses the same format to keep the same
// number of bits of precision.
const sampleSource = t.createTextureFromTexelView(inputTexelView, {
const sampleSource = ttu.createTextureFromTexelView(t, inputTexelView, {
size: [kTextureSize, kTextureSize],
usage: GPUTextureUsage.TEXTURE_BINDING,
});
@@ -337,7 +339,8 @@ in view format and match in base format.`
const renderViewTexels = TexelView.fromTexelsAsColors(viewFormat, inputTexelView.color, {
clampToFormatRange: true,
});
t.expectTexelViewComparisonIsOkInTexture(
ttu.expectTexelViewComparisonIsOkInTexture(
t,
{ texture: singleSampleRenderTexture },
renderViewTexels,
[kTextureSize, kTextureSize],
@@ -349,7 +352,8 @@ in view format and match in base format.`
const resolveView = TexelView.fromTexelsAsColors(viewFormat, renderViewTexels.color, {
clampToFormatRange: true,
});
t.expectTexelViewComparisonIsOkInTexture(
ttu.expectTexelViewComparisonIsOkInTexture(
t,
{ texture: resolveTexture },
resolveView,
[kTextureSize, kTextureSize],

7
dom/webgpu/tests/cts/checkout/src/webgpu/api/operation/texture_view/write.spec.ts
View File

@@ -22,11 +22,12 @@ import {
kRegularTextureFormats,
RegularTextureFormat,
} from '../../../format_info.js';
import { AllFeaturesMaxLimitsGPUTest, GPUTest, TextureTestMixin } from '../../../gpu_test.js';
import { AllFeaturesMaxLimitsGPUTest, GPUTest } from '../../../gpu_test.js';
import * as ttu from '../../../texture_test_utils.js';
import { kFullscreenQuadVertexShaderCode } from '../../../util/shader.js';
import { TexelView } from '../../../util/texture/texel_view.js';
export const g = makeTestGroup(TextureTestMixin(AllFeaturesMaxLimitsGPUTest));
export const g = makeTestGroup(AllFeaturesMaxLimitsGPUTest);
const kTextureViewWriteMethods = [
'storage-write-fragment',
@@ -388,7 +389,7 @@ TODO: Test rgb10a2uint when TexelRepresentation.numericRange is made per-compone
);
// [1] Use copySinglePixelTextureToBufferUsingComputePass to check multisampled texture.
t.expectTexelViewComparisonIsOkInTexture({ texture }, expectedTexelView, [
ttu.expectTexelViewComparisonIsOkInTexture(t, { texture }, expectedTexelView, [
kTextureSize,
kTextureSize,
]);

12
dom/webgpu/tests/cts/checkout/src/webgpu/api/operation/uncapturederror.spec.ts
View File

@@ -1,5 +1,5 @@
export const description = `
Tests for GPUDevice.onuncapturederror.
Tests for GPUDevice.onuncapturederror / addEventListener('uncapturederror')
`;
import { makeTestGroup } from '../../../common/framework/test_group.js';
@@ -12,12 +12,16 @@ g.test('iff_uncaptured')
.desc(
`{validation, out-of-memory} error should fire uncapturederror iff not captured by a scope.`
)
.params(u => u.combine('errorType', kGeneratableErrorScopeFilters))
.params(u =>
u
.combine('useOnuncapturederror', [false, true])
.combine('errorType', kGeneratableErrorScopeFilters)
)
.fn(async t => {
const { errorType } = t.params;
const { useOnuncapturederror, errorType } = t.params;
const uncapturedErrorEvent = await t.expectUncapturedError(() => {
t.generateError(errorType);
});
}, useOnuncapturederror);
t.expect(t.isInstanceOfError(errorType, uncapturedErrorEvent.error));
});

11
dom/webgpu/tests/cts/checkout/src/webgpu/api/validation/buffer/create.spec.ts
View File

@@ -10,10 +10,10 @@ import {
kBufferUsages,
} from '../../../capability_info.js';
import { GPUConst } from '../../../constants.js';
import { AllFeaturesMaxLimitsGPUTest } from '../../../gpu_test.js';
import { kMaxSafeMultipleOf8 } from '../../../util/math.js';
import { AllFeaturesMaxLimitsValidationTest } from '../validation_test.js';
export const g = makeTestGroup(AllFeaturesMaxLimitsValidationTest);
export const g = makeTestGroup(AllFeaturesMaxLimitsGPUTest);
assert(kBufferSizeAlignment === 4);
g.test('size')
@@ -36,10 +36,9 @@ g.test('size')
const { mappedAtCreation, size } = t.params;
const isValid = !mappedAtCreation || size % kBufferSizeAlignment === 0;
const usage = BufferUsage.COPY_SRC;
t.expectGPUError(
'validation',
() => t.createBufferTracked({ size, usage, mappedAtCreation }),
!isValid
t.shouldThrow(isValid ? false : 'RangeError', () =>
t.createBufferTracked({ size, usage, mappedAtCreation })
);
});

7
dom/webgpu/tests/cts/checkout/src/webgpu/api/validation/buffer/destroy.spec.ts
View File

@@ -5,9 +5,10 @@ Validation tests for GPUBuffer.destroy.
import { makeTestGroup } from '../../../../common/framework/test_group.js';
import { kBufferUsages } from '../../../capability_info.js';
import { GPUConst } from '../../../constants.js';
import { AllFeaturesMaxLimitsValidationTest } from '../validation_test.js';
import { AllFeaturesMaxLimitsGPUTest } from '../../../gpu_test.js';
import * as vtu from '../validation_test_utils.js';
export const g = makeTestGroup(AllFeaturesMaxLimitsValidationTest);
export const g = makeTestGroup(AllFeaturesMaxLimitsGPUTest);
g.test('all_usages')
.desc('Test destroying buffers of every usage type.')
@@ -28,7 +29,7 @@ g.test('all_usages')
g.test('error_buffer')
.desc('Test that error buffers may be destroyed without generating validation errors.')
.fn(t => {
const buf = t.getErrorBuffer();
const buf = vtu.getErrorBuffer(t);
buf.destroy();
});

7
dom/webgpu/tests/cts/checkout/src/webgpu/api/validation/buffer/mapping.spec.ts
View File

@@ -7,9 +7,10 @@ import { attemptGarbageCollection } from '../../../../common/util/collect_garbag
import { assert, unreachable } from '../../../../common/util/util.js';
import { kBufferUsages } from '../../../capability_info.js';
import { GPUConst } from '../../../constants.js';
import { AllFeaturesMaxLimitsValidationTest } from '../validation_test.js';
import { AllFeaturesMaxLimitsGPUTest } from '../../../gpu_test.js';
import * as vtu from '../validation_test_utils.js';
class F extends AllFeaturesMaxLimitsValidationTest {
class F extends AllFeaturesMaxLimitsGPUTest {
async testMapAsyncCall(
expectation:
| 'success'
@@ -149,7 +150,7 @@ g.test('mapAsync,invalidBuffer')
.paramsSubcasesOnly(u => u.combine('mapMode', kMapModeOptions))
.fn(async t => {
const { mapMode } = t.params;
const buffer = t.getErrorBuffer();
const buffer = vtu.getErrorBuffer(t);
await t.testMapAsyncCall(
{ validationError: true, earlyRejection: false, rejectName: 'OperationError' },
buffer,

4
dom/webgpu/tests/cts/checkout/src/webgpu/api/validation/buffer/threading.spec.ts
View File

@@ -9,6 +9,6 @@ TODO:
`;
import { makeTestGroup } from '../../../../common/framework/test_group.js';
import { AllFeaturesMaxLimitsValidationTest } from '../validation_test.js';
import { AllFeaturesMaxLimitsGPUTest } from '../../../gpu_test.js';
export const g = makeTestGroup(AllFeaturesMaxLimitsValidationTest);
export const g = makeTestGroup(AllFeaturesMaxLimitsGPUTest);

4
dom/webgpu/tests/cts/checkout/src/webgpu/api/validation/capability_checks/features/query_types.spec.ts
View File

@@ -3,9 +3,9 @@ Tests for capability checking for features enabling optional query types.
`;
import { makeTestGroup } from '../../../../../common/framework/test_group.js';
import { UniqueFeaturesAndLimitsValidationTest } from '../../validation_test.js';
import { UniqueFeaturesOrLimitsGPUTest } from '../../../../gpu_test.js';
export const g = makeTestGroup(UniqueFeaturesAndLimitsValidationTest);
export const g = makeTestGroup(UniqueFeaturesOrLimitsGPUTest);
g.test('createQuerySet')
.desc(

120
dom/webgpu/tests/cts/checkout/src/webgpu/api/validation/capability_checks/features/texture_formats.spec.ts
View File

@@ -7,16 +7,19 @@ import { getGPU } from '../../../../../common/util/navigator_gpu.js';
import { assert } from '../../../../../common/util/util.js';
import { kCanvasTextureFormats } from '../../../../capability_info.js';
import {
kASTCCompressedTextureFormats,
kBCCompressedTextureFormats,
getBlockInfoForTextureFormat,
isDepthOrStencilTextureFormat,
isTextureFormatPossiblyStorageReadable,
isTextureFormatPossiblyUsableAsColorRenderAttachment,
kOptionalTextureFormats,
} from '../../../../format_info.js';
import { UniqueFeaturesOrLimitsGPUTest } from '../../../../gpu_test.js';
import { kAllCanvasTypes, createCanvas } from '../../../../util/create_elements.js';
import { UniqueFeaturesAndLimitsValidationTest } from '../../validation_test.js';
import * as vtu from '../../validation_test_utils.js';
export const g = makeTestGroup(UniqueFeaturesAndLimitsValidationTest);
export const g = makeTestGroup(UniqueFeaturesOrLimitsGPUTest);
g.test('texture_descriptor')
.desc(
@@ -126,6 +129,94 @@ g.test('texture_view_descriptor')
});
});
g.test('texture_compression_bc_sliced_3d')
.desc(
`
Tests that creating a 3D texture with BC compressed format fails if the features don't contain
'texture-compression-bc' and 'texture-compression-bc-sliced-3d'.
`
)
.params(u =>
u
.combine('format', kBCCompressedTextureFormats)
.combine('supportsBC', [false, true])
.combine('supportsBCSliced3D', [false, true])
)
.beforeAllSubcases(t => {
const { supportsBC, supportsBCSliced3D } = t.params;
const requiredFeatures: GPUFeatureName[] = [];
if (supportsBC) {
requiredFeatures.push('texture-compression-bc');
}
if (supportsBCSliced3D) {
requiredFeatures.push('texture-compression-bc-sliced-3d');
}
t.selectDeviceOrSkipTestCase({ requiredFeatures });
})
.fn(t => {
const { format, supportsBC, supportsBCSliced3D } = t.params;
t.skipIfTextureFormatNotSupported(format);
const info = getBlockInfoForTextureFormat(format);
const descriptor: GPUTextureDescriptor = {
size: [info.blockWidth, info.blockHeight, 1],
dimension: '3d',
format,
usage: GPUTextureUsage.TEXTURE_BINDING,
};
t.expectValidationError(() => {
t.createTextureTracked(descriptor);
}, !supportsBC || !supportsBCSliced3D);
});
g.test('texture_compression_astc_sliced_3d')
.desc(
`
Tests that creating a 3D texture with ASTC compressed format fails if the features don't contain
'texture-compression-astc' and 'texture-compression-astc-sliced-3d'.
`
)
.params(u =>
u
.combine('format', kASTCCompressedTextureFormats)
.combine('supportsASTC', [false, true])
.combine('supportsASTCSliced3D', [false, true])
)
.beforeAllSubcases(t => {
const { supportsASTC, supportsASTCSliced3D } = t.params;
const requiredFeatures: GPUFeatureName[] = [];
if (supportsASTC) {
requiredFeatures.push('texture-compression-astc');
}
if (supportsASTCSliced3D) {
requiredFeatures.push('texture-compression-astc-sliced-3d');
}
t.selectDeviceOrSkipTestCase({ requiredFeatures });
})
.fn(t => {
const { format, supportsASTC, supportsASTCSliced3D } = t.params;
t.skipIfTextureFormatNotSupported(format);
const info = getBlockInfoForTextureFormat(format);
const descriptor: GPUTextureDescriptor = {
size: [info.blockWidth, info.blockHeight, 1],
dimension: '3d',
format,
usage: GPUTextureUsage.TEXTURE_BINDING,
};
t.expectValidationError(() => {
t.createTextureTracked(descriptor);
}, !supportsASTC || !supportsASTCSliced3D);
});
g.test('canvas_configuration')
.desc(
`
@@ -289,7 +380,8 @@ g.test('color_target_state')
const { isAsync, format, enable_required_feature } = t.params;
t.skipIfTextureFormatNotUsableAsRenderAttachment(format);
t.doCreateRenderPipelineTest(
vtu.doCreateRenderPipelineTest(
t,
isAsync,
enable_required_feature,
{
@@ -344,7 +436,8 @@ g.test('depth_stencil_state')
.fn(t => {
const { isAsync, format, enable_required_feature } = t.params;
t.doCreateRenderPipelineTest(
vtu.doCreateRenderPipelineTest(
t,
isAsync,
enable_required_feature,
{
@@ -446,15 +539,28 @@ g.test('render_bundle_encoder_descriptor_depth_stencil_format')
g.test('check_capability_guarantees')
.desc(
`check "texture-compression-bc" is supported or both "texture-compression-etc2" and "texture-compression-astc" are supported.`
`check any adapter returned by requestAdapter() must provide the following guarantees:
- "texture-compression-bc" is supported or both "texture-compression-etc2" and "texture-compression-astc" are supported
- either "texture-compression-bc" or "texture-compression-bc-sliced-3d" is supported, both must be supported.
`
)
.fn(async t => {
const adapter = await getGPU(t.rec).requestAdapter();
assert(adapter !== null);
const features = adapter.features;
const supportsBC = features.has('texture-compression-bc');
const supportsETC2ASTC =
features.has('texture-compression-etc2') && features.has('texture-compression-astc');
const supportsBCSliced3D = features.has('texture-compression-bc-sliced-3d');
t.expect(supportsBC || supportsETC2ASTC, 'Adapter must support BC or both ETC2 and ASTC');
if (supportsBC || supportsBCSliced3D) {
t.expect(
features.has('texture-compression-bc') ||
(features.has('texture-compression-etc2') && features.has('texture-compression-astc'))
supportsBC && supportsBCSliced3D,
'If BC or BC Sliced 3D is supported, both must be'
);
}
});

45
dom/webgpu/tests/cts/checkout/src/webgpu/api/validation/compute_pipeline.spec.ts
View File

@@ -4,6 +4,7 @@ createComputePipeline and createComputePipelineAsync validation tests.
Note: entry point matching tests are in shader_module/entry_point.spec.ts
`;
import { AllFeaturesMaxLimitsGPUTest } from '../.././gpu_test.js';
import { makeTestGroup } from '../../../common/framework/test_group.js';
import { keysOf } from '../../../common/util/data_tables.js';
import { kValue } from '../../util/constants.js';
@@ -15,9 +16,9 @@ import {
getAPIBindGroupLayoutForResource,
doResourcesMatch,
} from './utils.js';
import { AllFeaturesMaxLimitsValidationTest } from './validation_test.js';
import * as vtu from './validation_test_utils.js';
class F extends AllFeaturesMaxLimitsValidationTest {
class F extends AllFeaturesMaxLimitsGPUTest {
getShaderModule(
shaderStage: TShaderStage = 'compute',
entryPoint: string = 'main'
@@ -40,7 +41,7 @@ Call the API with valid compute shader and matching valid entryPoint, making sur
.params(u => u.combine('isAsync', [true, false]))
.fn(t => {
const { isAsync } = t.params;
t.doCreateComputePipelineTest(isAsync, true, {
vtu.doCreateComputePipelineTest(t, isAsync, true, {
layout: 'auto',
compute: { module: t.getShaderModule('compute', 'main'), entryPoint: 'main' },
});
@@ -55,10 +56,10 @@ Tests calling createComputePipeline(Async) with a invalid compute shader, and ch
.params(u => u.combine('isAsync', [true, false]))
.fn(t => {
const { isAsync } = t.params;
t.doCreateComputePipelineTest(isAsync, false, {
vtu.doCreateComputePipelineTest(t, isAsync, false, {
layout: 'auto',
compute: {
module: t.createInvalidShaderModule(),
module: vtu.createInvalidShaderModule(t),
entryPoint: 'main',
},
});
@@ -85,7 +86,7 @@ and check that the APIs only accept compute shader.
entryPoint: 'main',
},
};
t.doCreateComputePipelineTest(isAsync, shaderModuleStage === 'compute', descriptor);
vtu.doCreateComputePipelineTest(t, isAsync, shaderModuleStage === 'compute', descriptor);
});
g.test('shader_module,device_mismatch')
@@ -111,7 +112,7 @@ g.test('shader_module,device_mismatch')
},
};
t.doCreateComputePipelineTest(isAsync, !mismatched, descriptor);
vtu.doCreateComputePipelineTest(t, isAsync, !mismatched, descriptor);
});
g.test('pipeline_layout,device_mismatch')
@@ -134,7 +135,7 @@ g.test('pipeline_layout,device_mismatch')
},
};
t.doCreateComputePipelineTest(isAsync, !mismatched, descriptor);
vtu.doCreateComputePipelineTest(t, isAsync, !mismatched, descriptor);
});
g.test('limits,workgroup_storage_size')
@@ -172,7 +173,7 @@ Tests calling createComputePipeline(Async) validation for compute using <= devic
entryPoint: 'main',
},
};
t.doCreateComputePipelineTest(isAsync, count <= countAtLimit, descriptor);
vtu.doCreateComputePipelineTest(t, isAsync, count <= countAtLimit, descriptor);
});
g.test('limits,invocations_per_workgroup')
@@ -210,7 +211,8 @@ Tests calling createComputePipeline(Async) validation for compute using <= devic
},
};
t.doCreateComputePipelineTest(
vtu.doCreateComputePipelineTest(
t,
isAsync,
size[0] * size[1] * size[2] <= t.device.limits.maxComputeInvocationsPerWorkgroup,
descriptor
@@ -262,7 +264,7 @@ Tests calling createComputePipeline(Async) validation for compute workgroup_size
workgroupX <= t.device.limits.maxComputeWorkgroupSizeX &&
workgroupY <= t.device.limits.maxComputeWorkgroupSizeY &&
workgroupZ <= t.device.limits.maxComputeWorkgroupSizeZ;
t.doCreateComputePipelineTest(isAsync, _success, descriptor);
vtu.doCreateComputePipelineTest(t, isAsync, _success, descriptor);
});
g.test('overrides,identifier')
@@ -317,7 +319,7 @@ Tests calling createComputePipeline(Async) validation for overridable constants
},
};
t.doCreateComputePipelineTest(isAsync, _success, descriptor);
vtu.doCreateComputePipelineTest(t, isAsync, _success, descriptor);
});
g.test('overrides,uninitialized')
@@ -375,7 +377,7 @@ Tests calling createComputePipeline(Async) validation for uninitialized overrida
},
};
t.doCreateComputePipelineTest(isAsync, _success, descriptor);
vtu.doCreateComputePipelineTest(t, isAsync, _success, descriptor);
});
g.test('overrides,value,type_error')
@@ -412,7 +414,7 @@ Tests calling createComputePipeline(Async) validation for constant values like i
},
};
t.doCreateComputePipelineTest(isAsync, _success, descriptor, 'TypeError');
vtu.doCreateComputePipelineTest(t, isAsync, _success, descriptor, 'TypeError');
});
g.test('overrides,value,validation_error')
@@ -473,7 +475,7 @@ TODO(#2060): test with last_castable_pipeline_override.
},
};
t.doCreateComputePipelineTest(isAsync, _success, descriptor);
vtu.doCreateComputePipelineTest(t, isAsync, _success, descriptor);
});
g.test('overrides,entry_point,validation_error')
@@ -507,7 +509,7 @@ Tests that pipeline constant (override) errors only trigger on entry point usage
},
};
t.doCreateComputePipelineTest(isAsync, pipeEntryPoint === 'main_success', descriptor);
vtu.doCreateComputePipelineTest(t, isAsync, pipeEntryPoint === 'main_success', descriptor);
});
g.test('overrides,value,validation_error,f16')
@@ -566,7 +568,7 @@ clarity on whether values like f16.positive.last_castable_pipeline_override woul
},
};
t.doCreateComputePipelineTest(isAsync, _success, descriptor);
vtu.doCreateComputePipelineTest(t, isAsync, _success, descriptor);
});
const kOverridesWorkgroupSizeShaders = {
@@ -620,7 +622,7 @@ Tests calling createComputePipeline(Async) validation for overridable constants
},
};
t.doCreateComputePipelineTest(isAsync, _success, descriptor);
vtu.doCreateComputePipelineTest(t, isAsync, _success, descriptor);
});
g.test('overrides,workgroup_size,limits')
@@ -655,7 +657,7 @@ Tests calling createComputePipeline(Async) validation for overridable constants
},
};
t.doCreateComputePipelineTest(isAsync, _success, descriptor);
vtu.doCreateComputePipelineTest(t, isAsync, _success, descriptor);
};
testFn(limits.maxComputeWorkgroupSizeX, 1, 1, true);
@@ -718,7 +720,7 @@ Tests calling createComputePipeline(Async) validation for overridable constants
},
};
t.doCreateComputePipelineTest(isAsync, _success, descriptor);
vtu.doCreateComputePipelineTest(t, isAsync, _success, descriptor);
};
testFn(1, 1, true);
@@ -763,7 +765,8 @@ g.test('resource_compatibility')
entryPoint: 'main',
},
};
t.doCreateComputePipelineTest(
vtu.doCreateComputePipelineTest(
t,
t.params.isAsync,
doResourcesMatch(apiResource, wgslResource),
descriptor

28
dom/webgpu/tests/cts/checkout/src/webgpu/api/validation/createBindGroup.spec.ts
View File

@@ -4,6 +4,7 @@ export const description = `
TODO: Ensure sure tests cover all createBindGroup validation rules.
`;
import { AllFeaturesMaxLimitsGPUTest, kResourceStates } from '../.././gpu_test.js';
import { makeTestGroup } from '../../../common/framework/test_group.js';
import { assert, makeValueTestVariant, unreachable } from '../../../common/util/util.js';
import {
@@ -25,10 +26,9 @@ import {
} from '../../capability_info.js';
import { GPUConst } from '../../constants.js';
import { kPossibleStorageTextureFormats, kRegularTextureFormats } from '../../format_info.js';
import { kResourceStates } from '../../gpu_test.js';
import { getTextureDimensionFromView } from '../../util/texture/base.js';
import { AllFeaturesMaxLimitsValidationTest } from './validation_test.js';
import * as vtu from './validation_test_utils.js';
const kTestFormat: GPUTextureFormat = 'r32float';
@@ -37,7 +37,7 @@ function clone<T extends GPUTextureDescriptor>(descriptor: T): T {
}
function skipIfResourceNotSupportedInStages(
t: AllFeaturesMaxLimitsValidationTest,
t: AllFeaturesMaxLimitsGPUTest,
entry: BGLEntry,
visibility: number
) {
@@ -69,7 +69,7 @@ function skipIfResourceNotSupportedInStages(
}
}
export const g = makeTestGroup(AllFeaturesMaxLimitsValidationTest);
export const g = makeTestGroup(AllFeaturesMaxLimitsGPUTest);
g.test('binding_count_mismatch')
.desc('Test that the number of entries must match the number of entries in the BindGroupLayout.')
@@ -95,7 +95,7 @@ g.test('binding_count_mismatch')
for (let i = 0; i < bindGroupEntryCount; ++i) {
entries.push({
binding: i,
resource: { buffer: t.getStorageBuffer() },
resource: { buffer: vtu.getStorageBuffer(t) },
});
}
@@ -127,7 +127,7 @@ g.test('binding_must_be_present_in_layout')
});
const descriptor = {
entries: [{ binding, resource: { buffer: t.getStorageBuffer() } }],
entries: [{ binding, resource: { buffer: vtu.getStorageBuffer(t) } }],
layout: bindGroupLayout,
};
@@ -154,7 +154,7 @@ g.test('binding_must_contain_resource_defined_in_layout')
entries: [{ binding: 0, visibility: GPUShaderStage.COMPUTE, ...entry }],
});
const resource = t.getBindingResource(resourceType);
const resource = vtu.getBindingResource(t, resourceType);
const IsStorageTextureResourceType = (resourceType: BindableResource) => {
switch (resourceType) {
@@ -581,7 +581,7 @@ g.test('buffer,resource_state')
],
});
const buffer = t.createBufferWithState(state, {
const buffer = vtu.createBufferWithState(t, state, {
usage: info.usage,
size: 4,
});
@@ -631,7 +631,7 @@ g.test('texture,resource_state')
? info.usage | GPUConst.TextureUsage.RENDER_ATTACHMENT
: info.usage;
const format = entry.storageTexture !== undefined ? 'r32float' : 'rgba8unorm';
const texture = t.createTextureWithState(state, {
const texture = vtu.createTextureWithState(t, state, {
usage,
size: [1, 1],
format,
@@ -683,7 +683,7 @@ g.test('bind_group_layout,device_mismatch')
entries: [
{
binding: 0,
resource: { buffer: t.getUniformBuffer() },
resource: { buffer: vtu.getUniformBuffer(t) },
},
],
});
@@ -728,11 +728,11 @@ g.test('binding_resources,device_mismatch')
skipIfResourceNotSupportedInStages(t, entry, visibility);
const resource0 = resource0Mismatched
? t.getDeviceMismatchedBindingResource(info.resource)
: t.getBindingResource(info.resource);
? vtu.getDeviceMismatchedBindingResource(t, info.resource)
: vtu.getBindingResource(t, info.resource);
const resource1 = resource1Mismatched
? t.getDeviceMismatchedBindingResource(info.resource)
: t.getBindingResource(info.resource);
? vtu.getDeviceMismatchedBindingResource(t, info.resource)
: vtu.getBindingResource(t, info.resource);
const bgl = t.device.createBindGroupLayout({
entries: [

5
dom/webgpu/tests/cts/checkout/src/webgpu/api/validation/createBindGroupLayout.spec.ts
View File

@@ -4,6 +4,7 @@ createBindGroupLayout validation tests.
TODO: make sure tests are complete.
`;
import { AllFeaturesMaxLimitsGPUTest } from '../.././gpu_test.js';
import { kUnitCaseParamsBuilder } from '../../../common/framework/params_builder.js';
import { makeTestGroup } from '../../../common/framework/test_group.js';
import {
@@ -25,8 +26,6 @@ import {
kAllTextureFormats,
} from '../../format_info.js';
import { AllFeaturesMaxLimitsValidationTest } from './validation_test.js';
function clone<T extends GPUBindGroupLayoutDescriptor>(descriptor: T): T {
return JSON.parse(JSON.stringify(descriptor));
}
@@ -77,7 +76,7 @@ function isValidBGLEntryForStages(device: GPUDevice, visibility: number, entry:
: true;
}
export const g = makeTestGroup(AllFeaturesMaxLimitsValidationTest);
export const g = makeTestGroup(AllFeaturesMaxLimitsGPUTest);
g.test('duplicate_bindings')
.desc('Test that uniqueness of binding numbers across entries is enforced.')

5
dom/webgpu/tests/cts/checkout/src/webgpu/api/validation/createPipelineLayout.spec.ts
View File

@@ -4,6 +4,7 @@ createPipelineLayout validation tests.
TODO: review existing tests, write descriptions, and make sure tests are complete.
`;
import { AllFeaturesMaxLimitsGPUTest } from '../.././gpu_test.js';
import { makeTestGroup } from '../../../common/framework/test_group.js';
import { count } from '../../../common/util/util.js';
import {
@@ -13,13 +14,11 @@ import {
} from '../../capability_info.js';
import { GPUConst } from '../../constants.js';
import { AllFeaturesMaxLimitsValidationTest } from './validation_test.js';
function clone<T extends GPUBindGroupLayoutDescriptor>(descriptor: T): T {
return JSON.parse(JSON.stringify(descriptor));
}
export const g = makeTestGroup(AllFeaturesMaxLimitsValidationTest);
export const g = makeTestGroup(AllFeaturesMaxLimitsGPUTest);
g.test('number_of_dynamic_buffers_exceeds_the_maximum_value')
.desc(

5
dom/webgpu/tests/cts/checkout/src/webgpu/api/validation/createSampler.spec.ts
View File

@@ -2,11 +2,10 @@ export const description = `
createSampler validation tests.
`;
import { AllFeaturesMaxLimitsGPUTest } from '../.././gpu_test.js';
import { makeTestGroup } from '../../../common/framework/test_group.js';
import { AllFeaturesMaxLimitsValidationTest } from './validation_test.js';
export const g = makeTestGroup(AllFeaturesMaxLimitsValidationTest);
export const g = makeTestGroup(AllFeaturesMaxLimitsGPUTest);
g.test('lodMinAndMaxClamp')
.desc('test different combinations of min and max clamp values')

16
dom/webgpu/tests/cts/checkout/src/webgpu/api/validation/createTexture.spec.ts
View File

@@ -1,5 +1,6 @@
export const description = `createTexture validation tests.`;
import { AllFeaturesMaxLimitsGPUTest } from '../.././gpu_test.js';
import { makeTestGroup } from '../../../common/framework/test_group.js';
import { assert, makeValueTestVariant } from '../../../common/util/util.js';
import { kTextureDimensions, kTextureUsages } from '../../capability_info.js';
@@ -20,12 +21,11 @@ import {
isTextureFormatPossiblyStorageReadable,
isColorTextureFormat,
textureFormatsAreViewCompatible,
textureDimensionAndFormatCompatibleForDevice,
} from '../../format_info.js';
import { maxMipLevelCount } from '../../util/texture/base.js';
import { AllFeaturesMaxLimitsValidationTest } from './validation_test.js';
export const g = makeTestGroup(AllFeaturesMaxLimitsValidationTest);
export const g = makeTestGroup(AllFeaturesMaxLimitsGPUTest);
g.test('zero_size_and_usage')
.desc(
@@ -101,7 +101,8 @@ g.test('zero_size_and_usage')
g.test('dimension_type_and_format_compatibility')
.desc(
`Test every dimension type on every format. Note that compressed formats and depth/stencil formats are not valid for 1D/3D dimension types.`
`Test every dimension type on every format. Note that compressed formats and depth/stencil formats are not valid
for 1D dimension types while it depends on the format for 3D types.`
)
.params(u =>
u //
@@ -120,9 +121,12 @@ g.test('dimension_type_and_format_compatibility')
usage: GPUTextureUsage.TEXTURE_BINDING,
};
t.expectValidationError(() => {
t.expectValidationError(
() => {
t.createTextureTracked(descriptor);
}, !textureDimensionAndFormatCompatible(dimension, format));
},
!textureDimensionAndFormatCompatibleForDevice(t.device, dimension, format)
);
});
g.test('mipLevelCount,format')

8
dom/webgpu/tests/cts/checkout/src/webgpu/api/validation/createView.spec.ts
View File

@@ -1,5 +1,6 @@
export const description = `createView validation tests.`;
import { AllFeaturesMaxLimitsGPUTest, kResourceStates } from '../.././gpu_test.js';
import { kUnitCaseParamsBuilder } from '../../../common/framework/params_builder.js';
import { makeTestGroup } from '../../../common/framework/test_group.js';
import { unreachable } from '../../../common/util/util.js';
@@ -20,7 +21,6 @@ import {
getBlockInfoForTextureFormat,
isTextureFormatPossiblyUsableAsRenderAttachment,
} from '../../format_info.js';
import { kResourceStates } from '../../gpu_test.js';
import {
getTextureDimensionFromView,
reifyTextureViewDescriptor,
@@ -28,9 +28,9 @@ import {
} from '../../util/texture/base.js';
import { reifyExtent3D } from '../../util/unions.js';
import { AllFeaturesMaxLimitsValidationTest } from './validation_test.js';
import * as vtu from './validation_test_utils.js';
export const g = makeTestGroup(AllFeaturesMaxLimitsValidationTest);
export const g = makeTestGroup(AllFeaturesMaxLimitsGPUTest);
const kLevels = 6;
@@ -331,7 +331,7 @@ g.test('texture_state')
.paramsSubcasesOnly(u => u.combine('state', kResourceStates))
.fn(t => {
const { state } = t.params;
const texture = t.createTextureWithState(state);
const texture = vtu.createTextureWithState(t, state);
t.expectValidationError(() => {
texture.createView();

5
dom/webgpu/tests/cts/checkout/src/webgpu/api/validation/debugMarker.spec.ts
View File

@@ -2,11 +2,10 @@ export const description = `
Test validation of pushDebugGroup, popDebugGroup, and insertDebugMarker.
`;
import { AllFeaturesMaxLimitsGPUTest } from '../.././gpu_test.js';
import { makeTestGroup } from '../../../common/framework/test_group.js';
import { AllFeaturesMaxLimitsValidationTest } from './validation_test.js';
class F extends AllFeaturesMaxLimitsValidationTest {
class F extends AllFeaturesMaxLimitsGPUTest {
beginRenderPass(commandEncoder: GPUCommandEncoder): GPURenderPassEncoder {
const attachmentTexture = this.createTextureTracked({
format: 'rgba8unorm',

7
dom/webgpu/tests/cts/checkout/src/webgpu/api/validation/encoding/beginComputePass.spec.ts
View File

@@ -4,9 +4,10 @@ Tests for validation in beginComputePass and GPUComputePassDescriptor as its opt
import { makeTestGroup } from '../../../../common/framework/test_group.js';
import { kQueryTypes } from '../../../capability_info.js';
import { AllFeaturesMaxLimitsValidationTest } from '../validation_test.js';
import { AllFeaturesMaxLimitsGPUTest } from '../../../gpu_test.js';
import * as vtu from '../validation_test_utils.js';
class F extends AllFeaturesMaxLimitsValidationTest {
class F extends AllFeaturesMaxLimitsGPUTest {
tryComputePass(success: boolean, descriptor: GPUComputePassDescriptor): void {
const encoder = this.device.createCommandEncoder();
const computePass = encoder.beginComputePass(descriptor);
@@ -57,7 +58,7 @@ g.test('timestampWrites,invalid_query_set')
t.skipIfDeviceDoesNotSupportQueryType('timestamp');
const { querySetState } = t.params;
const querySet = t.createQuerySetWithState(querySetState, {
const querySet = vtu.createQuerySetWithState(t, querySetState, {
type: 'timestamp',
count: 1,
});

23
dom/webgpu/tests/cts/checkout/src/webgpu/api/validation/encoding/beginRenderPass.spec.ts
View File

@@ -22,9 +22,10 @@ Notes:
`;
import { makeTestGroup } from '../../../../common/framework/test_group.js';
import { AllFeaturesMaxLimitsValidationTest } from '../validation_test.js';
import { AllFeaturesMaxLimitsGPUTest } from '../../../gpu_test.js';
import * as vtu from '../validation_test_utils.js';
export const g = makeTestGroup(AllFeaturesMaxLimitsValidationTest);
export const g = makeTestGroup(AllFeaturesMaxLimitsGPUTest);
g.test('color_attachments,device_mismatch')
.desc(
@@ -68,17 +69,17 @@ g.test('color_attachments,device_mismatch')
const mismatched = view0Mismatched || target0Mismatched || view1Mismatched || target1Mismatched;
const view0Texture = view0Mismatched
? t.getDeviceMismatchedRenderTexture(4)
: t.getRenderTexture(4);
? vtu.getDeviceMismatchedRenderTexture(t, 4)
: vtu.getRenderTexture(t, 4);
const target0Texture = target0Mismatched
? t.getDeviceMismatchedRenderTexture()
: t.getRenderTexture();
? vtu.getDeviceMismatchedRenderTexture(t)
: vtu.getRenderTexture(t);
const view1Texture = view1Mismatched
? t.getDeviceMismatchedRenderTexture(4)
: t.getRenderTexture(4);
? vtu.getDeviceMismatchedRenderTexture(t, 4)
: vtu.getRenderTexture(t, 4);
const target1Texture = target1Mismatched
? t.getDeviceMismatchedRenderTexture()
: t.getRenderTexture();
? vtu.getDeviceMismatchedRenderTexture(t)
: vtu.getRenderTexture(t);
const encoder = t.createEncoder('non-pass');
const pass = encoder.encoder.beginRenderPass({
@@ -120,7 +121,7 @@ g.test('depth_stencil_attachment,device_mismatch')
};
const depthStencilTexture = mismatched
? t.getDeviceMismatchedTexture(descriptor)
? vtu.getDeviceMismatchedTexture(t, descriptor)
: t.createTextureTracked(descriptor);
const encoder = t.createEncoder('non-pass');

8
dom/webgpu/tests/cts/checkout/src/webgpu/api/validation/encoding/cmds/clearBuffer.spec.ts
View File

@@ -4,11 +4,11 @@ API validation tests for clearBuffer.
import { makeTestGroup } from '../../../../../common/framework/test_group.js';
import { kBufferUsages } from '../../../../capability_info.js';
import { kResourceStates } from '../../../../gpu_test.js';
import { kResourceStates, AllFeaturesMaxLimitsGPUTest } from '../../../../gpu_test.js';
import { kMaxSafeMultipleOf8 } from '../../../../util/math.js';
import { AllFeaturesMaxLimitsValidationTest } from '../../validation_test.js';
import * as vtu from '../../validation_test_utils.js';
class F extends AllFeaturesMaxLimitsValidationTest {
class F extends AllFeaturesMaxLimitsGPUTest {
TestClearBuffer(options: {
buffer: GPUBuffer;
offset: number | undefined;
@@ -34,7 +34,7 @@ g.test('buffer_state')
.fn(t => {
const { bufferState } = t.params;
const buffer = t.createBufferWithState(bufferState, {
const buffer = vtu.createBufferWithState(t, bufferState, {
size: 8,
usage: GPUBufferUsage.COPY_DST,
});

22
dom/webgpu/tests/cts/checkout/src/webgpu/api/validation/encoding/cmds/compute_pass.spec.ts
View File

@@ -8,16 +8,20 @@ import { makeTestGroup } from '../../../../../common/framework/test_group.js';
import { makeValueTestVariant } from '../../../../../common/util/util.js';
import { kBufferUsages } from '../../../../capability_info.js';
import { GPUConst } from '../../../../constants.js';
import { kResourceStates, ResourceState } from '../../../../gpu_test.js';
import { AllFeaturesMaxLimitsValidationTest } from '../../validation_test.js';
import {
kResourceStates,
ResourceState,
AllFeaturesMaxLimitsGPUTest,
} from '../../../../gpu_test.js';
import * as vtu from '../../validation_test_utils.js';
class F extends AllFeaturesMaxLimitsValidationTest {
class F extends AllFeaturesMaxLimitsGPUTest {
createComputePipeline(state: 'valid' | 'invalid'): GPUComputePipeline {
if (state === 'valid') {
return this.createNoOpComputePipeline();
return vtu.createNoOpComputePipeline(this);
}
return this.createErrorComputePipeline();
return vtu.createErrorComputePipeline(this);
}
createIndirectBuffer(state: ResourceState, data: Uint32Array): GPUBuffer {
@@ -119,7 +123,7 @@ g.test('dispatch_sizes')
const maxDispatch = t.device.limits.maxComputeWorkgroupsPerDimension;
const largeDimValue = makeValueTestVariant(maxDispatch, largeDimValueVariant);
const pipeline = t.createNoOpComputePipeline();
const pipeline = vtu.createNoOpComputePipeline(t);
const workSizes = [smallDimValue, smallDimValue, smallDimValue];
workSizes[largeDimIndex] = largeDimValue;
@@ -172,7 +176,7 @@ and an indirectBuffer with 6 elements.
)
.fn(t => {
const { state, offset } = t.params;
const pipeline = t.createNoOpComputePipeline();
const pipeline = vtu.createNoOpComputePipeline(t);
const buffer = t.createIndirectBuffer(state, kBufferData);
const { encoder, validateFinishAndSubmit } = t.createEncoder('compute pass');
@@ -195,7 +199,7 @@ g.test('indirect_dispatch_buffer,device_mismatch')
.fn(t => {
const { mismatched } = t.params;
const pipeline = t.createNoOpComputePipeline();
const pipeline = vtu.createNoOpComputePipeline(t);
const sourceDevice = mismatched ? t.mismatchedDevice : t.device;
@@ -238,7 +242,7 @@ g.test('indirect_dispatch_buffer,usage')
const bufferUsage = bufferUsage0 | bufferUsage1;
const layout = t.device.createPipelineLayout({ bindGroupLayouts: [] });
const pipeline = t.createNoOpComputePipeline(layout);
const pipeline = vtu.createNoOpComputePipeline(t, layout);
const buffer = t.createBufferTracked({
size: 16,

10
dom/webgpu/tests/cts/checkout/src/webgpu/api/validation/encoding/cmds/copyBufferToBuffer.spec.ts
View File

@@ -25,11 +25,11 @@ Test Plan:
import { makeTestGroup } from '../../../../../common/framework/test_group.js';
import { kBufferUsages } from '../../../../capability_info.js';
import { kResourceStates } from '../../../../gpu_test.js';
import { kResourceStates, AllFeaturesMaxLimitsGPUTest } from '../../../../gpu_test.js';
import { kMaxSafeMultipleOf8 } from '../../../../util/math.js';
import { AllFeaturesMaxLimitsValidationTest } from '../../validation_test.js';
import * as vtu from '../../validation_test_utils.js';
class F extends AllFeaturesMaxLimitsValidationTest {
class F extends AllFeaturesMaxLimitsGPUTest {
TestCopyBufferToBuffer(options: {
srcBuffer: GPUBuffer;
srcOffset: number;
@@ -66,11 +66,11 @@ g.test('buffer_state')
)
.fn(t => {
const { srcBufferState, dstBufferState } = t.params;
const srcBuffer = t.createBufferWithState(srcBufferState, {
const srcBuffer = vtu.createBufferWithState(t, srcBufferState, {
size: 16,
usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST,
});
const dstBuffer = t.createBufferWithState(dstBufferState, {
const dstBuffer = vtu.createBufferWithState(t, dstBufferState, {
size: 16,
usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST,
});

10
dom/webgpu/tests/cts/checkout/src/webgpu/api/validation/encoding/cmds/copyTextureToTexture.spec.ts
View File

@@ -15,11 +15,11 @@ import {
canCopyToAllAspectsOfTextureFormat,
ColorTextureFormat,
} from '../../../../format_info.js';
import { kResourceStates } from '../../../../gpu_test.js';
import { kResourceStates, AllFeaturesMaxLimitsGPUTest } from '../../../../gpu_test.js';
import { align, lcm } from '../../../../util/math.js';
import { AllFeaturesMaxLimitsValidationTest } from '../../validation_test.js';
import * as vtu from '../../validation_test_utils.js';
class F extends AllFeaturesMaxLimitsValidationTest {
class F extends AllFeaturesMaxLimitsGPUTest {
TestCopyTextureToTexture(
source: GPUTexelCopyTextureInfo,
destination: GPUTexelCopyTextureInfo,
@@ -90,8 +90,8 @@ g.test('copy_with_invalid_or_destroyed_texture')
usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.COPY_DST,
};
const srcTexture = t.createTextureWithState(srcState, textureDesc);
const dstTexture = t.createTextureWithState(dstState, textureDesc);
const srcTexture = vtu.createTextureWithState(t, srcState, textureDesc);
const dstTexture = vtu.createTextureWithState(t, dstState, textureDesc);
const isSubmitSuccess = srcState === 'valid' && dstState === 'valid';
const isFinishSuccess = srcState !== 'invalid' && dstState !== 'invalid';

4
dom/webgpu/tests/cts/checkout/src/webgpu/api/validation/encoding/cmds/debug.spec.ts
View File

@@ -14,10 +14,10 @@ Test Coverage:
`;
import { makeTestGroup } from '../../../../../common/framework/test_group.js';
import { AllFeaturesMaxLimitsGPUTest } from '../../../../gpu_test.js';
import { kEncoderTypes } from '../../../../util/command_buffer_maker.js';
import { AllFeaturesMaxLimitsValidationTest } from '../../validation_test.js';
export const g = makeTestGroup(AllFeaturesMaxLimitsValidationTest);
export const g = makeTestGroup(AllFeaturesMaxLimitsGPUTest);
g.test('debug_group_balanced')
.params(u =>

4
dom/webgpu/tests/cts/checkout/src/webgpu/api/validation/encoding/cmds/index_access.spec.ts
View File

@@ -3,9 +3,9 @@ Validation tests for indexed draws accessing the index buffer.
`;
import { makeTestGroup } from '../../../../../common/framework/test_group.js';
import { AllFeaturesMaxLimitsValidationTest } from '../../validation_test.js';
import { AllFeaturesMaxLimitsGPUTest } from '../../../../gpu_test.js';
class F extends AllFeaturesMaxLimitsValidationTest {
class F extends AllFeaturesMaxLimitsGPUTest {
createIndexBuffer(indexData: Iterable<number>): GPUBuffer {
return this.makeBufferWithContents(new Uint32Array(indexData), GPUBufferUsage.INDEX);
}

32
dom/webgpu/tests/cts/checkout/src/webgpu/api/validation/encoding/cmds/render/draw.spec.ts
View File

@@ -6,8 +6,8 @@ and parameters as expect.
import { makeTestGroup } from '../../../../../../common/framework/test_group.js';
import { kVertexFormatInfo } from '../../../../../capability_info.js';
import { GPUTest } from '../../../../../gpu_test.js';
import { AllFeaturesMaxLimitsValidationTest } from '../../../validation_test.js';
import { GPUTest, AllFeaturesMaxLimitsGPUTest } from '../../../../../gpu_test.js';
import * as vtu from '../../../validation_test_utils.js';
type VertexAttrib<A> = A & { shaderLocation: number };
type VertexBuffer<V, A> = V & {
@@ -98,7 +98,7 @@ function callDraw(
}
function makeTestPipeline(
test: AllFeaturesMaxLimitsValidationTest,
test: AllFeaturesMaxLimitsGPUTest,
buffers: VertexState<
{ stepMode: GPUVertexStepMode; arrayStride: number },
{
@@ -116,14 +116,14 @@ function makeTestPipeline(
layout: 'auto',
vertex: {
module: test.device.createShaderModule({
code: test.getNoOpShaderCode('VERTEX'),
code: vtu.getNoOpShaderCode('VERTEX'),
}),
entryPoint: 'main',
buffers: bufferLayouts,
},
fragment: {
module: test.device.createShaderModule({
code: test.getNoOpShaderCode('FRAGMENT'),
code: vtu.getNoOpShaderCode('FRAGMENT'),
}),
entryPoint: 'main',
targets: [{ format: 'rgba8unorm', writeMask: 0 }],
@@ -133,7 +133,7 @@ function makeTestPipeline(
}
function makeTestPipelineWithVertexAndInstanceBuffer(
test: AllFeaturesMaxLimitsValidationTest,
test: AllFeaturesMaxLimitsGPUTest,
arrayStride: number,
attributeFormat: GPUVertexFormat,
attributeOffset: number = 0
@@ -190,7 +190,7 @@ const kDefaultParameterForIndexedDraw = {
indexBufferSize: 2 * 200, // exact required bound size for index buffer
};
export const g = makeTestGroup(AllFeaturesMaxLimitsValidationTest);
export const g = makeTestGroup(AllFeaturesMaxLimitsGPUTest);
g.test(`unused_buffer_bound`)
.desc(
@@ -226,16 +226,16 @@ In this test we test that a small buffer bound to unused buffer slot won't cause
bufferOffset,
boundSize,
} = t.params;
const renderPipeline = t.createNoOpRenderPipeline();
const renderPipeline = vtu.createNoOpRenderPipeline(t);
const bufferSize = bufferOffset + boundSize;
const smallBuffer = t.createBufferWithState('valid', {
const smallBuffer = vtu.createBufferWithState(t, 'valid', {
size: bufferSize,
usage: GPUBufferUsage.INDEX | GPUBufferUsage.VERTEX,
});
// An index buffer of enough size, used if smallIndexBuffer === false
const { indexFormat, indexBufferSize } = kDefaultParameterForIndexedDraw;
const indexBuffer = t.createBufferWithState('valid', {
const indexBuffer = vtu.createBufferWithState(t, 'valid', {
size: indexBufferSize,
usage: GPUBufferUsage.INDEX,
});
@@ -320,7 +320,7 @@ drawIndexedIndirect as it is GPU-validated.
size: bufferSize,
usage: GPUBufferUsage.INDEX | GPUBufferUsage.COPY_DST,
};
const indexBuffer = t.createBufferWithState('valid', desc);
const indexBuffer = vtu.createBufferWithState(t, 'valid', desc);
const drawCallParam: DrawIndexedParameter = {
indexCount: drawIndexCount,
@@ -331,7 +331,7 @@ drawIndexedIndirect as it is GPU-validated.
const isFinishSuccess =
drawIndexCount <= bindingSizeInElements || drawType === 'drawIndexedIndirect';
const renderPipeline = t.createNoOpRenderPipeline();
const renderPipeline = vtu.createNoOpRenderPipeline(t);
for (const encoderType of ['render bundle', 'render pass'] as const) {
for (const setPipelineBeforeBuffer of [false, true]) {
@@ -514,11 +514,11 @@ success/error as expected. Such set of buffer parameters should include cases li
);
const instanceBufferSize = setBufferOffset + setInstanceBufferSize;
const vertexBuffer = t.createBufferWithState('valid', {
const vertexBuffer = vtu.createBufferWithState(t, 'valid', {
size: vertexBufferSize,
usage: GPUBufferUsage.VERTEX,
});
const instanceBuffer = t.createBufferWithState('valid', {
const instanceBuffer = vtu.createBufferWithState(t, 'valid', {
size: instanceBufferSize,
usage: GPUBufferUsage.VERTEX,
});
@@ -561,7 +561,7 @@ success/error as expected. Such set of buffer parameters should include cases li
size: indexBufferSize,
usage: GPUBufferUsage.INDEX | GPUBufferUsage.COPY_DST,
};
const indexBuffer = t.createBufferWithState('valid', desc);
const indexBuffer = vtu.createBufferWithState(t, 'valid', desc);
const drawParam: DrawIndexedParameter = {
indexCount,
@@ -679,7 +679,7 @@ buffer slot and index buffer will cause no validation error, with completely/par
requiredBufferSize = Math.max(requiredBufferSize, setIndexBufferOffset + setIndexBufferSize);
// Create the shared GPU buffer with both vertetx and index usage
const sharedBuffer = t.createBufferWithState('valid', {
const sharedBuffer = vtu.createBufferWithState(t, 'valid', {
size: requiredBufferSize,
usage: GPUBufferUsage.VERTEX | GPUBufferUsage.INDEX,
});

4
dom/webgpu/tests/cts/checkout/src/webgpu/api/validation/encoding/cmds/render/dynamic_state.spec.ts
View File

@@ -23,8 +23,8 @@ TODO: ensure existing tests cover these notes. Note many of these may be operati
`;
import { makeTestGroup } from '../../../../../../common/framework/test_group.js';
import { AllFeaturesMaxLimitsGPUTest } from '../../../../../gpu_test.js';
import { nextAfterF32 } from '../../../../../util/math.js';
import { AllFeaturesMaxLimitsValidationTest } from '../../../validation_test.js';
interface ViewportCall {
x: number;
@@ -42,7 +42,7 @@ interface ScissorCall {
h: number;
}
class F extends AllFeaturesMaxLimitsValidationTest {
class F extends AllFeaturesMaxLimitsGPUTest {
testViewportCall(
success: boolean,
v: ViewportCall,

18
dom/webgpu/tests/cts/checkout/src/webgpu/api/validation/encoding/cmds/render/indirect_draw.spec.ts
View File

@@ -4,14 +4,14 @@ Validation tests for drawIndirect/drawIndexedIndirect on render pass and render
import { makeTestGroup } from '../../../../../../common/framework/test_group.js';
import { GPUConst } from '../../../../../constants.js';
import { kResourceStates } from '../../../../../gpu_test.js';
import { AllFeaturesMaxLimitsValidationTest } from '../../../validation_test.js';
import { kResourceStates, AllFeaturesMaxLimitsGPUTest } from '../../../../../gpu_test.js';
import * as vtu from '../../../validation_test_utils.js';
import { kRenderEncodeTypeParams } from './render.js';
const kIndirectDrawTestParams = kRenderEncodeTypeParams.combine('indexed', [true, false] as const);
class F extends AllFeaturesMaxLimitsValidationTest {
class F extends AllFeaturesMaxLimitsGPUTest {
makeIndexBuffer(): GPUBuffer {
return this.createBufferTracked({
size: 16,
@@ -31,8 +31,8 @@ Tests indirect buffer must be valid.
.paramsSubcasesOnly(kIndirectDrawTestParams.combine('state', kResourceStates))
.fn(t => {
const { encoderType, indexed, state } = t.params;
const pipeline = t.createNoOpRenderPipeline();
const indirectBuffer = t.createBufferWithState(state, {
const pipeline = vtu.createNoOpRenderPipeline(t);
const indirectBuffer = vtu.createBufferWithState(t, state, {
size: 256,
usage: GPUBufferUsage.INDIRECT,
});
@@ -69,7 +69,7 @@ g.test('indirect_buffer,device_mismatch')
);
const { encoder, validateFinish } = t.createEncoder(encoderType);
encoder.setPipeline(t.createNoOpRenderPipeline());
encoder.setPipeline(vtu.createNoOpRenderPipeline(t));
if (indexed) {
encoder.setIndexBuffer(t.makeIndexBuffer(), 'uint32');
@@ -101,7 +101,7 @@ Tests indirect buffer must have 'Indirect' usage.
});
const { encoder, validateFinish } = t.createEncoder(encoderType);
encoder.setPipeline(t.createNoOpRenderPipeline());
encoder.setPipeline(vtu.createNoOpRenderPipeline(t));
if (indexed) {
const indexBuffer = t.makeIndexBuffer();
encoder.setIndexBuffer(indexBuffer, 'uint32');
@@ -121,7 +121,7 @@ Tests indirect offset must be a multiple of 4.
.paramsSubcasesOnly(kIndirectDrawTestParams.combine('indirectOffset', [0, 2, 4] as const))
.fn(t => {
const { encoderType, indexed, indirectOffset } = t.params;
const pipeline = t.createNoOpRenderPipeline();
const pipeline = vtu.createNoOpRenderPipeline(t);
const indirectBuffer = t.createBufferTracked({
size: 256,
usage: GPUBufferUsage.INDIRECT,
@@ -181,7 +181,7 @@ Tests indirect draw calls with various indirect offsets and buffer sizes.
)
.fn(t => {
const { encoderType, indexed, indirectOffset, bufferSize, _valid } = t.params;
const pipeline = t.createNoOpRenderPipeline();
const pipeline = vtu.createNoOpRenderPipeline(t);
const indirectBuffer = t.createBufferTracked({
size: bufferSize,
usage: GPUBufferUsage.INDIRECT,

22
dom/webgpu/tests/cts/checkout/src/webgpu/api/validation/encoding/cmds/render/indirect_multi_draw.spec.ts
View File

@@ -9,14 +9,14 @@ import {
kMaxUnsignedLongValue,
kMaxUnsignedLongLongValue,
} from '../../../../../constants.js';
import { kResourceStates } from '../../../../../gpu_test.js';
import { AllFeaturesMaxLimitsValidationTest } from '../../../validation_test.js';
import { kResourceStates, AllFeaturesMaxLimitsGPUTest } from '../../../../../gpu_test.js';
import * as vtu from '../../../validation_test_utils.js';
const kIndirectMultiDrawTestParams = kUnitCaseParamsBuilder
.combine('indexed', [true, false] as const)
.combine('useDrawCountBuffer', [true, false] as const);
class F extends AllFeaturesMaxLimitsValidationTest {
class F extends AllFeaturesMaxLimitsGPUTest {
makeIndexBuffer(): GPUBuffer {
return this.createBufferTracked({
size: 16,
@@ -50,19 +50,19 @@ Tests indirect and draw count buffers must be valid.
.fn(t => {
t.skipIfDeviceDoesNotHaveFeature('chromium-experimental-multi-draw-indirect' as GPUFeatureName);
const { indexed, indirectState, useDrawCountBuffer, drawCountState } = t.params;
const indirectBuffer = t.createBufferWithState(indirectState, {
const indirectBuffer = vtu.createBufferWithState(t, indirectState, {
size: 256,
usage: GPUBufferUsage.INDIRECT,
});
const drawCountBuffer = useDrawCountBuffer
? t.createBufferWithState(drawCountState, {
? vtu.createBufferWithState(t, drawCountState, {
size: 256,
usage: GPUBufferUsage.INDIRECT,
})
: undefined;
const { encoder, validateFinishAndSubmit } = t.createEncoder('render pass');
encoder.setPipeline(t.createNoOpRenderPipeline());
encoder.setPipeline(vtu.createNoOpRenderPipeline(t));
if (indexed) {
encoder.setIndexBuffer(t.makeIndexBuffer(), 'uint32');
// eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -117,7 +117,7 @@ g.test('buffers,device_mismatch')
: undefined;
const { encoder, validateFinish } = t.createEncoder('render pass');
encoder.setPipeline(t.createNoOpRenderPipeline());
encoder.setPipeline(vtu.createNoOpRenderPipeline(t));
if (indexed) {
encoder.setIndexBuffer(t.makeIndexBuffer(), 'uint32');
// eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -164,7 +164,7 @@ Tests indirect and draw count buffers must have 'Indirect' usage.
: undefined;
const { encoder, validateFinish } = t.createEncoder('render pass');
encoder.setPipeline(t.createNoOpRenderPipeline());
encoder.setPipeline(vtu.createNoOpRenderPipeline(t));
if (indexed) {
encoder.setIndexBuffer(t.makeIndexBuffer(), 'uint32');
// eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -214,7 +214,7 @@ Tests indirect and draw count offsets must be a multiple of 4.
: undefined;
const { encoder, validateFinish } = t.createEncoder('render pass');
encoder.setPipeline(t.createNoOpRenderPipeline());
encoder.setPipeline(vtu.createNoOpRenderPipeline(t));
if (indexed) {
encoder.setIndexBuffer(t.makeIndexBuffer(), 'uint32');
// eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -288,7 +288,7 @@ Tests multi indirect draw calls with various indirect offsets and buffer sizes w
});
const { encoder, validateFinish } = t.createEncoder('render pass');
encoder.setPipeline(t.createNoOpRenderPipeline());
encoder.setPipeline(vtu.createNoOpRenderPipeline(t));
if (indexed) {
encoder.setIndexBuffer(t.makeIndexBuffer(), 'uint32');
// eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -339,7 +339,7 @@ Tests multi indirect draw calls with various draw count offsets, and draw count
});
const { encoder, validateFinish } = t.createEncoder('render pass');
encoder.setPipeline(t.createNoOpRenderPipeline());
encoder.setPipeline(vtu.createNoOpRenderPipeline(t));
if (indexed) {
encoder.setIndexBuffer(t.makeIndexBuffer(), 'uint32');
// eslint-disable-next-line @typescript-eslint/no-explicit-any

8
dom/webgpu/tests/cts/checkout/src/webgpu/api/validation/encoding/cmds/render/setIndexBuffer.spec.ts
View File

@@ -4,12 +4,12 @@ Validation tests for setIndexBuffer on render pass and render bundle.
import { makeTestGroup } from '../../../../../../common/framework/test_group.js';
import { GPUConst } from '../../../../../constants.js';
import { kResourceStates } from '../../../../../gpu_test.js';
import { AllFeaturesMaxLimitsValidationTest } from '../../../validation_test.js';
import { kResourceStates, AllFeaturesMaxLimitsGPUTest } from '../../../../../gpu_test.js';
import * as vtu from '../../../validation_test_utils.js';
import { kRenderEncodeTypeParams, buildBufferOffsetAndSizeOOBTestParams } from './render.js';
export const g = makeTestGroup(AllFeaturesMaxLimitsValidationTest);
export const g = makeTestGroup(AllFeaturesMaxLimitsGPUTest);
g.test('index_buffer_state')
.desc(
@@ -20,7 +20,7 @@ Tests index buffer must be valid.
.paramsSubcasesOnly(kRenderEncodeTypeParams.combine('state', kResourceStates))
.fn(t => {
const { encoderType, state } = t.params;
const indexBuffer = t.createBufferWithState(state, {
const indexBuffer = vtu.createBufferWithState(t, state, {
size: 16,
usage: GPUBufferUsage.INDEX,
});

7
dom/webgpu/tests/cts/checkout/src/webgpu/api/validation/encoding/cmds/render/setPipeline.spec.ts
View File

@@ -3,12 +3,13 @@ Validation tests for setPipeline on render pass and render bundle.
`;
import { makeTestGroup } from '../../../../../../common/framework/test_group.js';
import { AllFeaturesMaxLimitsGPUTest } from '../../../../../gpu_test.js';
import { kRenderEncodeTypes } from '../../../../../util/command_buffer_maker.js';
import { AllFeaturesMaxLimitsValidationTest } from '../../../validation_test.js';
import * as vtu from '../../../validation_test_utils.js';
import { kRenderEncodeTypeParams } from './render.js';
export const g = makeTestGroup(AllFeaturesMaxLimitsValidationTest);
export const g = makeTestGroup(AllFeaturesMaxLimitsGPUTest);
g.test('invalid_pipeline')
.desc(
@@ -21,7 +22,7 @@ Tests setPipeline should generate an error iff using an 'invalid' pipeline.
)
.fn(t => {
const { encoderType, state } = t.params;
const pipeline = t.createRenderPipelineWithState(state);
const pipeline = vtu.createRenderPipelineWithState(t, state);
const { encoder, validateFinish } = t.createEncoder(encoderType);
encoder.setPipeline(pipeline);

10
dom/webgpu/tests/cts/checkout/src/webgpu/api/validation/encoding/cmds/render/setVertexBuffer.spec.ts
View File

@@ -5,12 +5,12 @@ Validation tests for setVertexBuffer on render pass and render bundle.
import { makeTestGroup } from '../../../../../../common/framework/test_group.js';
import { makeValueTestVariant } from '../../../../../../common/util/util.js';
import { GPUConst } from '../../../../../constants.js';
import { kResourceStates } from '../../../../../gpu_test.js';
import { AllFeaturesMaxLimitsValidationTest } from '../../../validation_test.js';
import { kResourceStates, AllFeaturesMaxLimitsGPUTest } from '../../../../../gpu_test.js';
import * as vtu from '../../../validation_test_utils.js';
import { kRenderEncodeTypeParams, buildBufferOffsetAndSizeOOBTestParams } from './render.js';
export const g = makeTestGroup(AllFeaturesMaxLimitsValidationTest);
export const g = makeTestGroup(AllFeaturesMaxLimitsGPUTest);
g.test('slot')
.desc(
@@ -30,7 +30,7 @@ Tests slot must be less than the maxVertexBuffers in device limits.
const maxVertexBuffers = t.device.limits.maxVertexBuffers;
const slot = makeValueTestVariant(maxVertexBuffers, slotVariant);
const vertexBuffer = t.createBufferWithState('valid', {
const vertexBuffer = vtu.createBufferWithState(t, 'valid', {
size: 16,
usage: GPUBufferUsage.VERTEX,
});
@@ -49,7 +49,7 @@ Tests vertex buffer must be valid.
.paramsSubcasesOnly(kRenderEncodeTypeParams.combine('state', kResourceStates))
.fn(t => {
const { encoderType, state } = t.params;
const vertexBuffer = t.createBufferWithState(state, {
const vertexBuffer = vtu.createBufferWithState(t, state, {
size: 16,
usage: GPUBufferUsage.VERTEX,
});

4
dom/webgpu/tests/cts/checkout/src/webgpu/api/validation/encoding/cmds/render/state_tracking.spec.ts
View File

@@ -4,9 +4,9 @@ Validation tests for setVertexBuffer/setIndexBuffer state (not validation). See
import { makeTestGroup } from '../../../../../../common/framework/test_group.js';
import { range } from '../../../../../../common/util/util.js';
import { AllFeaturesMaxLimitsValidationTest } from '../../../validation_test.js';
import { AllFeaturesMaxLimitsGPUTest } from '../../../../../gpu_test.js';
class F extends AllFeaturesMaxLimitsValidationTest {
class F extends AllFeaturesMaxLimitsGPUTest {
getVertexBuffer(): GPUBuffer {
return this.createBufferTracked({
size: 256,

4
dom/webgpu/tests/cts/checkout/src/webgpu/api/validation/encoding/cmds/render_pass.spec.ts
View File

@@ -9,6 +9,6 @@ TODO:
`;
import { makeTestGroup } from '../../../../../common/framework/test_group.js';
import { AllFeaturesMaxLimitsValidationTest } from '../../validation_test.js';
import { AllFeaturesMaxLimitsGPUTest } from '../../../../gpu_test.js';
export const g = makeTestGroup(AllFeaturesMaxLimitsValidationTest);
export const g = makeTestGroup(AllFeaturesMaxLimitsGPUTest);

16
dom/webgpu/tests/cts/checkout/src/webgpu/api/validation/encoding/cmds/setBindGroup.spec.ts
View File

@@ -17,14 +17,18 @@ import {
kMinDynamicBufferOffsetAlignment,
} from '../../../../capability_info.js';
import { GPUConst } from '../../../../constants.js';
import { kResourceStates, ResourceState } from '../../../../gpu_test.js';
import {
kResourceStates,
ResourceState,
AllFeaturesMaxLimitsGPUTest,
} from '../../../../gpu_test.js';
import {
kProgrammableEncoderTypes,
ProgrammableEncoderType,
} from '../../../../util/command_buffer_maker.js';
import { AllFeaturesMaxLimitsValidationTest } from '../../validation_test.js';
import * as vtu from '../../validation_test_utils.js';
class F extends AllFeaturesMaxLimitsValidationTest {
class F extends AllFeaturesMaxLimitsGPUTest {
encoderTypeToStageFlag(encoderType: ProgrammableEncoderType): GPUShaderStageFlags {
switch (encoderType) {
case 'compute pass':
@@ -43,7 +47,7 @@ class F extends AllFeaturesMaxLimitsValidationTest {
): GPUBindingResource {
switch (resourceType) {
case 'texture': {
const texture = this.createTextureWithState('valid');
const texture = vtu.createTextureWithState(this, 'valid');
const view = texture.createView();
if (state === 'destroyed') {
texture.destroy();
@@ -52,7 +56,7 @@ class F extends AllFeaturesMaxLimitsValidationTest {
}
case 'buffer':
return {
buffer: this.createBufferWithState(state, {
buffer: vtu.createBufferWithState(this, state, {
size: 4,
usage: GPUBufferUsage.UNIFORM,
}),
@@ -358,7 +362,7 @@ g.test('u32array_start_and_length')
entries: range(dynamicOffsetsDataLength, i => ({
binding: i,
resource: {
buffer: t.createBufferWithState('valid', {
buffer: vtu.createBufferWithState(t, 'valid', {
size: kBindingSize,
usage: GPUBufferUsage.UNIFORM,
}),

4
dom/webgpu/tests/cts/checkout/src/webgpu/api/validation/encoding/createRenderBundleEncoder.spec.ts
View File

@@ -16,13 +16,13 @@ import {
kDepthStencilFormats,
kPossibleColorRenderableTextureFormats,
} from '../../../format_info.js';
import { AllFeaturesMaxLimitsValidationTest } from '../validation_test.js';
import { AllFeaturesMaxLimitsGPUTest } from '../../../gpu_test.js';
// MAINTENANCE_TODO: This should be changed to kMaxColorAttachmentsToTest
// when this is made a MaxLimitTest (see above).
const kMaxColorAttachments = getDefaultLimits('core').maxColorAttachments.default;
export const g = makeTestGroup(AllFeaturesMaxLimitsValidationTest);
export const g = makeTestGroup(AllFeaturesMaxLimitsGPUTest);
g.test('attachment_state,limits,maxColorAttachments')
.desc(`Tests that attachment state must have <= device.limits.maxColorAttachments.`)

7
dom/webgpu/tests/cts/checkout/src/webgpu/api/validation/encoding/encoder_open_state.spec.ts
View File

@@ -6,11 +6,12 @@ GPURenderPassEncoder when the encoder is not finished.
import { makeTestGroup } from '../../../../common/framework/test_group.js';
import { keysOf } from '../../../../common/util/data_tables.js';
import { unreachable } from '../../../../common/util/util.js';
import { AllFeaturesMaxLimitsValidationTest } from '../validation_test.js';
import { AllFeaturesMaxLimitsGPUTest } from '../../../gpu_test.js';
import * as vtu from '../validation_test_utils.js';
import { beginRenderPassWithQuerySet } from './queries/common.js';
class F extends AllFeaturesMaxLimitsValidationTest {
class F extends AllFeaturesMaxLimitsGPUTest {
createRenderPipelineForTest(): GPURenderPipeline {
return this.device.createRenderPipeline({
layout: 'auto',
@@ -561,7 +562,7 @@ g.test('compute_pass_commands')
usage: GPUBufferUsage.INDIRECT,
});
const computePipeline = t.createNoOpComputePipeline();
const computePipeline = vtu.createNoOpComputePipeline(t);
const bindGroup = t.createBindGroupForTest();

4
dom/webgpu/tests/cts/checkout/src/webgpu/api/validation/encoding/encoder_state.spec.ts
View File

@@ -18,9 +18,9 @@ TODO:
import { makeTestGroup } from '../../../../common/framework/test_group.js';
import { objectEquals } from '../../../../common/util/util.js';
import { AllFeaturesMaxLimitsValidationTest } from '../validation_test.js';
import { AllFeaturesMaxLimitsGPUTest } from '../../../gpu_test.js';
class F extends AllFeaturesMaxLimitsValidationTest {
class F extends AllFeaturesMaxLimitsGPUTest {
beginRenderPass(commandEncoder: GPUCommandEncoder, view: GPUTextureView): GPURenderPassEncoder {
return commandEncoder.beginRenderPass({
colorAttachments: [

9
dom/webgpu/tests/cts/checkout/src/webgpu/api/validation/encoding/programmable/pipeline_bind_group_compat.spec.ts
View File

@@ -21,11 +21,12 @@ import {
ValidBindableResource,
} from '../../../../capability_info.js';
import { GPUConst } from '../../../../constants.js';
import { AllFeaturesMaxLimitsGPUTest } from '../../../../gpu_test.js';
import {
ProgrammableEncoderType,
kProgrammableEncoderTypes,
} from '../../../../util/command_buffer_maker.js';
import { AllFeaturesMaxLimitsValidationTest } from '../../validation_test.js';
import * as vtu from '../../validation_test_utils.js';
const kComputeCmds = ['dispatch', 'dispatchIndirect'] as const;
type ComputeCmd = (typeof kComputeCmds)[number];
@@ -71,7 +72,7 @@ const kCompatTestParams = kUnitCaseParamsBuilder
.expand('call', p => getTestCmds(p.encoderType))
.combine('callWithZero', [true, false]);
class F extends AllFeaturesMaxLimitsValidationTest {
class F extends AllFeaturesMaxLimitsGPUTest {
getIndexBuffer(): GPUBuffer {
return this.createBufferTracked({
size: 8 * Uint32Array.BYTES_PER_ELEMENT,
@@ -164,7 +165,7 @@ class F extends AllFeaturesMaxLimitsValidationTest {
createBindGroupWithLayout(bglEntries: Array<GPUBindGroupLayoutEntry>): GPUBindGroup {
const bgEntries: Array<GPUBindGroupEntry> = [];
for (const entry of bglEntries) {
const resource = this.getBindingResource(this.getBindingResourceType(entry));
const resource = vtu.getBindingResource(this, this.getBindingResourceType(entry));
bgEntries.push({
binding: entry.binding,
resource,
@@ -539,7 +540,7 @@ g.test('buffer_binding,render_pipeline')
);
// Create fixed bindGroup
const uniformBuffer = t.getUniformBuffer();
const uniformBuffer = vtu.getUniformBuffer(t);
const bindGroup = t.device.createBindGroup({
entries: [

4
dom/webgpu/tests/cts/checkout/src/webgpu/api/validation/encoding/queries/begin_end.spec.ts
View File

@@ -3,11 +3,11 @@ Validation for encoding begin/endable queries.
`;
import { makeTestGroup } from '../../../../../common/framework/test_group.js';
import { AllFeaturesMaxLimitsValidationTest } from '../../validation_test.js';
import { AllFeaturesMaxLimitsGPUTest } from '../../../../gpu_test.js';
import { beginRenderPassWithQuerySet, createQuerySetWithType } from './common.js';
export const g = makeTestGroup(AllFeaturesMaxLimitsValidationTest);
export const g = makeTestGroup(AllFeaturesMaxLimitsGPUTest);
g.test('occlusion_query,begin_end_balance')
.desc(

9
dom/webgpu/tests/cts/checkout/src/webgpu/api/validation/encoding/queries/general.spec.ts
View File

@@ -4,11 +4,12 @@ Validation for encoding queries.
import { makeTestGroup } from '../../../../../common/framework/test_group.js';
import { kQueryTypes } from '../../../../capability_info.js';
import { AllFeaturesMaxLimitsValidationTest } from '../../validation_test.js';
import { AllFeaturesMaxLimitsGPUTest } from '../../../../gpu_test.js';
import * as vtu from '../../validation_test_utils.js';
import { createQuerySetWithType } from './common.js';
export const g = makeTestGroup(AllFeaturesMaxLimitsValidationTest);
export const g = makeTestGroup(AllFeaturesMaxLimitsGPUTest);
g.test('occlusion_query,query_type')
.desc(
@@ -40,7 +41,7 @@ Tests that begin occlusion query with a invalid query set that failed during cre
)
.paramsSubcasesOnly(u => u.combine('querySetState', ['valid', 'invalid'] as const))
.fn(t => {
const occlusionQuerySet = t.createQuerySetWithState(t.params.querySetState);
const occlusionQuerySet = vtu.createQuerySetWithState(t, t.params.querySetState);
const encoder = t.createEncoder('render pass', { occlusionQuerySet });
encoder.encoder.beginOcclusionQuery(0);
@@ -114,7 +115,7 @@ TODO: writeTimestamp is removed from the spec so it's skipped if it TypeErrors.
t.skipIfDeviceDoesNotSupportQueryType('timestamp');
const { querySetState } = t.params;
const querySet = t.createQuerySetWithState(querySetState, {
const querySet = vtu.createQuerySetWithState(t, querySetState, {
type: 'timestamp',
count: 2,
});

10
dom/webgpu/tests/cts/checkout/src/webgpu/api/validation/encoding/queries/resolveQuerySet.spec.ts
View File

@@ -3,10 +3,10 @@ Validation tests for resolveQuerySet.
`;
import { makeTestGroup } from '../../../../../common/framework/test_group.js';
import { GPUConst } from '../../../../constants.js';
import { kResourceStates } from '../../../../gpu_test.js';
import { AllFeaturesMaxLimitsValidationTest } from '../../validation_test.js';
import { kResourceStates, AllFeaturesMaxLimitsGPUTest } from '../../../../gpu_test.js';
import * as vtu from '../../validation_test_utils.js';
export const g = makeTestGroup(AllFeaturesMaxLimitsValidationTest);
export const g = makeTestGroup(AllFeaturesMaxLimitsGPUTest);
export const kQueryCount = 2;
@@ -29,9 +29,9 @@ Tests that resolve query set must be with valid query set and destination buffer
const shouldBeValid = querySetState !== 'invalid' && destinationState !== 'invalid';
const shouldSubmitSuccess = querySetState === 'valid' && destinationState === 'valid';
const querySet = t.createQuerySetWithState(querySetState);
const querySet = vtu.createQuerySetWithState(t, querySetState);
const destination = t.createBufferWithState(destinationState, {
const destination = vtu.createBufferWithState(t, destinationState, {
size: kQueryCount * 8,
usage: GPUBufferUsage.QUERY_RESOLVE,
});

4
dom/webgpu/tests/cts/checkout/src/webgpu/api/validation/encoding/render_bundle.spec.ts
View File

@@ -4,9 +4,9 @@ Tests execution of render bundles.
import { makeTestGroup } from '../../../../common/framework/test_group.js';
import { kDepthStencilFormats } from '../../../format_info.js';
import { AllFeaturesMaxLimitsValidationTest } from '../validation_test.js';
import { AllFeaturesMaxLimitsGPUTest } from '../../../gpu_test.js';
export const g = makeTestGroup(AllFeaturesMaxLimitsValidationTest);
export const g = makeTestGroup(AllFeaturesMaxLimitsGPUTest);
g.test('empty_bundle_list')
.desc(

5
dom/webgpu/tests/cts/checkout/src/webgpu/api/validation/getBindGroupLayout.spec.ts
View File

@@ -2,12 +2,11 @@ export const description = `
getBindGroupLayout validation tests.
`;
import { AllFeaturesMaxLimitsGPUTest } from '../.././gpu_test.js';
import { makeTestGroup } from '../../../common/framework/test_group.js';
import { assert } from '../../../common/util/util.js';
import { AllFeaturesMaxLimitsValidationTest } from './validation_test.js';
export const g = makeTestGroup(AllFeaturesMaxLimitsValidationTest);
export const g = makeTestGroup(AllFeaturesMaxLimitsGPUTest);
g.test('index_range,explicit_layout')
.desc(

5
dom/webgpu/tests/cts/checkout/src/webgpu/api/validation/gpu_external_texture_expiration.spec.ts
View File

@@ -2,6 +2,7 @@ export const description = `
GPUExternalTexture expiration mechanism validation tests.
`;
import { AllFeaturesMaxLimitsGPUTest } from '../.././gpu_test.js';
import { makeTestGroup } from '../../../common/framework/test_group.js';
import { assert } from '../../../common/util/util.js';
import {
@@ -12,9 +13,7 @@ import {
waitForNextTask,
} from '../../web_platform/util.js';
import { AllFeaturesMaxLimitsValidationTest } from './validation_test.js';
class GPUExternalTextureExpireTest extends AllFeaturesMaxLimitsValidationTest {
class GPUExternalTextureExpireTest extends AllFeaturesMaxLimitsGPUTest {
submitCommandBuffer(bindGroup: GPUBindGroup, success: boolean): void {
const kHeight = 16;
const kWidth = 16;

3
dom/webgpu/tests/cts/checkout/src/webgpu/api/validation/image_copy/buffer_related.spec.ts
View File

@@ -11,6 +11,7 @@ import {
} from '../../../format_info.js';
import { kResourceStates } from '../../../gpu_test.js';
import { kImageCopyTypes } from '../../../util/texture/layout.js';
import * as vtu from '../validation_test_utils.js';
import { ImageCopyTest, formatCopyableWithMethod } from './image_copy.js';
@@ -34,7 +35,7 @@ Test that the buffer must be valid and not destroyed.
const { method, state } = t.params;
// A valid buffer.
const buffer = t.createBufferWithState(state, {
const buffer = vtu.createBufferWithState(t, state, {
size: 16,
usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST,
});

4
dom/webgpu/tests/cts/checkout/src/webgpu/api/validation/image_copy/buffer_texture_copies.spec.ts
View File

@@ -12,11 +12,11 @@ import {
depthStencilBufferTextureCopySupported,
depthStencilFormatAspectSize,
} from '../../../format_info.js';
import { AllFeaturesMaxLimitsGPUTest } from '../../../gpu_test.js';
import { align } from '../../../util/math.js';
import { kBufferCopyAlignment, kBytesPerRowAlignment } from '../../../util/texture/layout.js';
import { AllFeaturesMaxLimitsValidationTest } from '../validation_test.js';
class ImageCopyTest extends AllFeaturesMaxLimitsValidationTest {
class ImageCopyTest extends AllFeaturesMaxLimitsGPUTest {
testCopyBufferToTexture(
source: GPUTexelCopyBufferInfo,
destination: GPUTexelCopyTextureInfo,

4
dom/webgpu/tests/cts/checkout/src/webgpu/api/validation/image_copy/image_copy.ts
View File

@@ -8,11 +8,11 @@ import {
canCopyFromAllAspectsOfTextureFormat,
canCopyToAllAspectsOfTextureFormat,
} from '../../../format_info.js';
import { AllFeaturesMaxLimitsGPUTest } from '../../../gpu_test.js';
import { align } from '../../../util/math.js';
import { ImageCopyType } from '../../../util/texture/layout.js';
import { AllFeaturesMaxLimitsValidationTest } from '../validation_test.js';
export class ImageCopyTest extends AllFeaturesMaxLimitsValidationTest {
export class ImageCopyTest extends AllFeaturesMaxLimitsGPUTest {
testRun(
textureCopyView: GPUTexelCopyTextureInfo,
textureDataLayout: GPUTexelCopyBufferLayout,

3
dom/webgpu/tests/cts/checkout/src/webgpu/api/validation/image_copy/texture_related.spec.ts
View File

@@ -17,6 +17,7 @@ import { kResourceStates } from '../../../gpu_test.js';
import { align } from '../../../util/math.js';
import { virtualMipSize } from '../../../util/texture/base.js';
import { kImageCopyTypes } from '../../../util/texture/layout.js';
import * as vtu from '../validation_test_utils.js';
import {
ImageCopyTest,
@@ -50,7 +51,7 @@ Test that the texture must be valid and not destroyed.
.fn(t => {
const { method, textureState, size, dimension } = t.params;
const texture = t.createTextureWithState(textureState, {
const texture = vtu.createTextureWithState(t, textureState, {
size,
dimension,
format: 'rgba8unorm',

Some files were not shown because too many files have changed in this diff Show More