From 10ba6a69286fae5467e265f584e15cab5375ee54 Mon Sep 17 00:00:00 2001 From: Kunal Mohan Date: Sat, 25 Jul 2020 17:22:04 +0530 Subject: [PATCH 1/6] add webgpu cts and update manifest --- tests/wpt/config.ini | 5 + tests/wpt/webgpu/meta/MANIFEST.json | 653 ++++++++++++++++ tests/wpt/webgpu/tests/LICENSE.txt | 26 + tests/wpt/webgpu/tests/README.md | 10 + .../webgpu/common/framework/file_loader.js | 39 + .../tests/webgpu/common/framework/fixture.js | 124 +++ .../tests/webgpu/common/framework/glsl.js | 33 + .../common/framework/gpu/device_pool.js | 152 ++++ .../common/framework/gpu/implementation.js | 19 + .../common/framework/logging/log_message.js | 48 ++ .../webgpu/common/framework/logging/logger.js | 35 + .../webgpu/common/framework/logging/result.js | 3 + .../framework/logging/test_case_recorder.js | 139 ++++ .../webgpu/common/framework/params_builder.js | 117 +++ .../webgpu/common/framework/params_utils.js | 27 + .../webgpu/common/framework/query/compare.js | 93 +++ .../framework/query/encode_selectively.js | 21 + .../common/framework/query/parseQuery.js | 128 ++++ .../webgpu/common/framework/query/query.js | 127 +++ .../common/framework/query/separators.js | 14 + .../framework/query/stringify_params.js | 26 + .../common/framework/query/validQueryPart.js | 3 + .../webgpu/common/framework/test_group.js | 162 ++++ .../common/framework/test_suite_listing.js | 3 + .../tests/webgpu/common/framework/tree.js | 393 ++++++++++ .../common/framework/util/async_mutex.js | 38 + .../common/framework/util/collect_garbage.js | 47 ++ .../webgpu/common/framework/util/stack.js | 78 ++ .../webgpu/common/framework/util/timeout.js | 3 + .../webgpu/common/framework/util/util.js | 72 ++ .../tests/webgpu/common/framework/version.js | 3 + .../webgpu/common/runtime/helper/options.js | 7 + .../runtime/helper/test_worker-worker.js | 26 + .../common/runtime/helper/test_worker.js | 51 ++ .../webgpu/tests/webgpu/common/runtime/wpt.js | 58 ++ tests/wpt/webgpu/tests/webgpu/cts.html | 71 ++ .../operation/buffers/create_mapped.spec.js | 25 + .../webgpu/api/operation/buffers/map.spec.js | 59 ++ .../api/operation/buffers/map_detach.spec.js | 69 ++ .../api/operation/buffers/map_oom.spec.js | 34 + .../api/operation/buffers/mapping_test.js | 34 + .../operation/command_buffer/basic.spec.js | 15 + .../command_buffer/compute/basic.spec.js | 74 ++ .../operation/command_buffer/copies.spec.js | 121 +++ .../command_buffer/render/basic.spec.js | 46 ++ .../command_buffer/render/rendering.spec.js | 85 +++ .../command_buffer/render/storeop.spec.js | 78 ++ .../webgpu/api/operation/fences.spec.js | 145 ++++ .../api/operation/render_pass/storeOp.spec.js | 24 + .../render_pipeline/culling_tests.spec.js | 165 ++++ .../copied_texture_clear.spec.js | 75 ++ .../depth_stencil_attachment_clear.spec.js | 213 ++++++ .../sampled_texture_clear.spec.js | 199 +++++ .../resource_init/texture_zero_init_test.js | 552 +++++++++++++ .../api/validation/createBindGroup.spec.js | 303 ++++++++ .../validation/createBindGroupLayout.spec.js | 335 ++++++++ .../validation/createPipelineLayout.spec.js | 95 +++ .../validation/createRenderPipeline.spec.js | 234 ++++++ .../api/validation/createTexture.spec.js | 145 ++++ .../webgpu/api/validation/createView.spec.js | 267 +++++++ .../encoding/cmds/index_access.spec.js | 135 ++++ .../webgpu/api/validation/error_scope.spec.js | 173 +++++ .../webgpu/api/validation/fences.spec.js | 88 +++ .../api/validation/queue_submit.spec.js | 43 ++ .../webgpu/api/validation/render_pass.spec.js | 152 ++++ .../validation/render_pass/storeOp.spec.js | 14 + .../validation/render_pass_descriptor.spec.js | 568 ++++++++++++++ .../api/validation/setBindGroup.spec.js | 193 +++++ .../api/validation/setBlendColor.spec.js | 49 ++ .../api/validation/setScissorRect.spec.js | 54 ++ .../validation/setStencilReference.spec.js | 43 ++ .../api/validation/setVertexBuffer.spec.js | 179 +++++ .../webgpu/api/validation/setViewport.spec.js | 73 ++ .../webgpu/api/validation/validation_test.js | 116 +++ .../api/validation/vertex_state.spec.js | 722 ++++++++++++++++++ .../tests/webgpu/webgpu/capability_info.js | 629 +++++++++++++++ .../tests/webgpu/webgpu/examples.spec.js | 103 +++ .../webgpu/tests/webgpu/webgpu/gpu_test.js | 292 +++++++ .../webgpu/webgpu/idl/constants/flags.spec.js | 59 ++ .../tests/webgpu/webgpu/idl/idl_test.js | 25 + .../wpt/webgpu/tests/webgpu/webgpu/listing.js | 437 +++++++++++ .../shader/execution/robust_access.spec.js | 337 ++++++++ .../execution/robust_access_vertex.spec.js | 451 +++++++++++ .../tests/webgpu/webgpu/util/conversion.js | 66 ++ .../webgpu/tests/webgpu/webgpu/util/math.js | 9 + .../webgpu/webgpu/util/texture/layout.js | 133 ++++ .../webgpu/webgpu/util/texture/subresource.js | 58 ++ .../webgpu/webgpu/util/texture/texelData.js | 359 +++++++++ .../canvas/context_creation.spec.js | 24 + .../copyImageBitmapToTexture.spec.js | 372 +++++++++ .../web-platform/reftests/canvas_clear.html | 10 + .../web-platform/reftests/canvas_clear.js | 29 + .../web-platform/reftests/canvas_complex.js | 78 ++ .../reftests/canvas_complex_bgra8unorm.html | 18 + .../web-platform/reftests/gpu_ref_test.js | 18 + .../reftests/ref/canvas_clear-ref.html | 12 + .../reftests/ref/canvas_complex-ref.html | 17 + 97 files changed, 12384 insertions(+) create mode 100644 tests/wpt/webgpu/meta/MANIFEST.json create mode 100644 tests/wpt/webgpu/tests/LICENSE.txt create mode 100644 tests/wpt/webgpu/tests/README.md create mode 100644 tests/wpt/webgpu/tests/webgpu/common/framework/file_loader.js create mode 100644 tests/wpt/webgpu/tests/webgpu/common/framework/fixture.js create mode 100644 tests/wpt/webgpu/tests/webgpu/common/framework/glsl.js create mode 100644 tests/wpt/webgpu/tests/webgpu/common/framework/gpu/device_pool.js create mode 100644 tests/wpt/webgpu/tests/webgpu/common/framework/gpu/implementation.js create mode 100644 tests/wpt/webgpu/tests/webgpu/common/framework/logging/log_message.js create mode 100644 tests/wpt/webgpu/tests/webgpu/common/framework/logging/logger.js create mode 100644 tests/wpt/webgpu/tests/webgpu/common/framework/logging/result.js create mode 100644 tests/wpt/webgpu/tests/webgpu/common/framework/logging/test_case_recorder.js create mode 100644 tests/wpt/webgpu/tests/webgpu/common/framework/params_builder.js create mode 100644 tests/wpt/webgpu/tests/webgpu/common/framework/params_utils.js create mode 100644 tests/wpt/webgpu/tests/webgpu/common/framework/query/compare.js create mode 100644 tests/wpt/webgpu/tests/webgpu/common/framework/query/encode_selectively.js create mode 100644 tests/wpt/webgpu/tests/webgpu/common/framework/query/parseQuery.js create mode 100644 tests/wpt/webgpu/tests/webgpu/common/framework/query/query.js create mode 100644 tests/wpt/webgpu/tests/webgpu/common/framework/query/separators.js create mode 100644 tests/wpt/webgpu/tests/webgpu/common/framework/query/stringify_params.js create mode 100644 tests/wpt/webgpu/tests/webgpu/common/framework/query/validQueryPart.js create mode 100644 tests/wpt/webgpu/tests/webgpu/common/framework/test_group.js create mode 100644 tests/wpt/webgpu/tests/webgpu/common/framework/test_suite_listing.js create mode 100644 tests/wpt/webgpu/tests/webgpu/common/framework/tree.js create mode 100644 tests/wpt/webgpu/tests/webgpu/common/framework/util/async_mutex.js create mode 100644 tests/wpt/webgpu/tests/webgpu/common/framework/util/collect_garbage.js create mode 100644 tests/wpt/webgpu/tests/webgpu/common/framework/util/stack.js create mode 100644 tests/wpt/webgpu/tests/webgpu/common/framework/util/timeout.js create mode 100644 tests/wpt/webgpu/tests/webgpu/common/framework/util/util.js create mode 100644 tests/wpt/webgpu/tests/webgpu/common/framework/version.js create mode 100644 tests/wpt/webgpu/tests/webgpu/common/runtime/helper/options.js create mode 100644 tests/wpt/webgpu/tests/webgpu/common/runtime/helper/test_worker-worker.js create mode 100644 tests/wpt/webgpu/tests/webgpu/common/runtime/helper/test_worker.js create mode 100644 tests/wpt/webgpu/tests/webgpu/common/runtime/wpt.js create mode 100644 tests/wpt/webgpu/tests/webgpu/cts.html create mode 100644 tests/wpt/webgpu/tests/webgpu/webgpu/api/operation/buffers/create_mapped.spec.js create mode 100644 tests/wpt/webgpu/tests/webgpu/webgpu/api/operation/buffers/map.spec.js create mode 100644 tests/wpt/webgpu/tests/webgpu/webgpu/api/operation/buffers/map_detach.spec.js create mode 100644 tests/wpt/webgpu/tests/webgpu/webgpu/api/operation/buffers/map_oom.spec.js create mode 100644 tests/wpt/webgpu/tests/webgpu/webgpu/api/operation/buffers/mapping_test.js create mode 100644 tests/wpt/webgpu/tests/webgpu/webgpu/api/operation/command_buffer/basic.spec.js create mode 100644 tests/wpt/webgpu/tests/webgpu/webgpu/api/operation/command_buffer/compute/basic.spec.js create mode 100644 tests/wpt/webgpu/tests/webgpu/webgpu/api/operation/command_buffer/copies.spec.js create mode 100644 tests/wpt/webgpu/tests/webgpu/webgpu/api/operation/command_buffer/render/basic.spec.js create mode 100644 tests/wpt/webgpu/tests/webgpu/webgpu/api/operation/command_buffer/render/rendering.spec.js create mode 100644 tests/wpt/webgpu/tests/webgpu/webgpu/api/operation/command_buffer/render/storeop.spec.js create mode 100644 tests/wpt/webgpu/tests/webgpu/webgpu/api/operation/fences.spec.js create mode 100644 tests/wpt/webgpu/tests/webgpu/webgpu/api/operation/render_pass/storeOp.spec.js create mode 100644 tests/wpt/webgpu/tests/webgpu/webgpu/api/operation/render_pipeline/culling_tests.spec.js create mode 100644 tests/wpt/webgpu/tests/webgpu/webgpu/api/operation/resource_init/copied_texture_clear.spec.js create mode 100644 tests/wpt/webgpu/tests/webgpu/webgpu/api/operation/resource_init/depth_stencil_attachment_clear.spec.js create mode 100644 tests/wpt/webgpu/tests/webgpu/webgpu/api/operation/resource_init/sampled_texture_clear.spec.js create mode 100644 tests/wpt/webgpu/tests/webgpu/webgpu/api/operation/resource_init/texture_zero_init_test.js create mode 100644 tests/wpt/webgpu/tests/webgpu/webgpu/api/validation/createBindGroup.spec.js create mode 100644 tests/wpt/webgpu/tests/webgpu/webgpu/api/validation/createBindGroupLayout.spec.js create mode 100644 tests/wpt/webgpu/tests/webgpu/webgpu/api/validation/createPipelineLayout.spec.js create mode 100644 tests/wpt/webgpu/tests/webgpu/webgpu/api/validation/createRenderPipeline.spec.js create mode 100644 tests/wpt/webgpu/tests/webgpu/webgpu/api/validation/createTexture.spec.js create mode 100644 tests/wpt/webgpu/tests/webgpu/webgpu/api/validation/createView.spec.js create mode 100644 tests/wpt/webgpu/tests/webgpu/webgpu/api/validation/encoding/cmds/index_access.spec.js create mode 100644 tests/wpt/webgpu/tests/webgpu/webgpu/api/validation/error_scope.spec.js create mode 100644 tests/wpt/webgpu/tests/webgpu/webgpu/api/validation/fences.spec.js create mode 100644 tests/wpt/webgpu/tests/webgpu/webgpu/api/validation/queue_submit.spec.js create mode 100644 tests/wpt/webgpu/tests/webgpu/webgpu/api/validation/render_pass.spec.js create mode 100644 tests/wpt/webgpu/tests/webgpu/webgpu/api/validation/render_pass/storeOp.spec.js create mode 100644 tests/wpt/webgpu/tests/webgpu/webgpu/api/validation/render_pass_descriptor.spec.js create mode 100644 tests/wpt/webgpu/tests/webgpu/webgpu/api/validation/setBindGroup.spec.js create mode 100644 tests/wpt/webgpu/tests/webgpu/webgpu/api/validation/setBlendColor.spec.js create mode 100644 tests/wpt/webgpu/tests/webgpu/webgpu/api/validation/setScissorRect.spec.js create mode 100644 tests/wpt/webgpu/tests/webgpu/webgpu/api/validation/setStencilReference.spec.js create mode 100644 tests/wpt/webgpu/tests/webgpu/webgpu/api/validation/setVertexBuffer.spec.js create mode 100644 tests/wpt/webgpu/tests/webgpu/webgpu/api/validation/setViewport.spec.js create mode 100644 tests/wpt/webgpu/tests/webgpu/webgpu/api/validation/validation_test.js create mode 100644 tests/wpt/webgpu/tests/webgpu/webgpu/api/validation/vertex_state.spec.js create mode 100644 tests/wpt/webgpu/tests/webgpu/webgpu/capability_info.js create mode 100644 tests/wpt/webgpu/tests/webgpu/webgpu/examples.spec.js create mode 100644 tests/wpt/webgpu/tests/webgpu/webgpu/gpu_test.js create mode 100644 tests/wpt/webgpu/tests/webgpu/webgpu/idl/constants/flags.spec.js create mode 100644 tests/wpt/webgpu/tests/webgpu/webgpu/idl/idl_test.js create mode 100644 tests/wpt/webgpu/tests/webgpu/webgpu/listing.js create mode 100644 tests/wpt/webgpu/tests/webgpu/webgpu/shader/execution/robust_access.spec.js create mode 100644 tests/wpt/webgpu/tests/webgpu/webgpu/shader/execution/robust_access_vertex.spec.js create mode 100644 tests/wpt/webgpu/tests/webgpu/webgpu/util/conversion.js create mode 100644 tests/wpt/webgpu/tests/webgpu/webgpu/util/math.js create mode 100644 tests/wpt/webgpu/tests/webgpu/webgpu/util/texture/layout.js create mode 100644 tests/wpt/webgpu/tests/webgpu/webgpu/util/texture/subresource.js create mode 100644 tests/wpt/webgpu/tests/webgpu/webgpu/util/texture/texelData.js create mode 100644 tests/wpt/webgpu/tests/webgpu/webgpu/web-platform/canvas/context_creation.spec.js create mode 100644 tests/wpt/webgpu/tests/webgpu/webgpu/web-platform/copyImageBitmapToTexture.spec.js create mode 100644 tests/wpt/webgpu/tests/webgpu/webgpu/web-platform/reftests/canvas_clear.html create mode 100644 tests/wpt/webgpu/tests/webgpu/webgpu/web-platform/reftests/canvas_clear.js create mode 100644 tests/wpt/webgpu/tests/webgpu/webgpu/web-platform/reftests/canvas_complex.js create mode 100644 tests/wpt/webgpu/tests/webgpu/webgpu/web-platform/reftests/canvas_complex_bgra8unorm.html create mode 100644 tests/wpt/webgpu/tests/webgpu/webgpu/web-platform/reftests/gpu_ref_test.js create mode 100644 tests/wpt/webgpu/tests/webgpu/webgpu/web-platform/reftests/ref/canvas_clear-ref.html create mode 100644 tests/wpt/webgpu/tests/webgpu/webgpu/web-platform/reftests/ref/canvas_complex-ref.html diff --git a/tests/wpt/config.ini b/tests/wpt/config.ini index d72eb2316e6..48a0c6fdb46 100644 --- a/tests/wpt/config.ini +++ b/tests/wpt/config.ini @@ -25,3 +25,8 @@ url_base = /_mozilla/ tests = webgl/tests metadata = webgl/meta url_base = /_webgl/ + +[manifest:webgpu] +tests = webgpu/tests +metadata = webgpu/meta +url_base = /_webgpu/ diff --git a/tests/wpt/webgpu/meta/MANIFEST.json b/tests/wpt/webgpu/meta/MANIFEST.json new file mode 100644 index 00000000000..d757e39a0c0 --- /dev/null +++ b/tests/wpt/webgpu/meta/MANIFEST.json @@ -0,0 +1,653 @@ +{ + "items": { + "reftest": { + "webgpu": { + "webgpu": { + "web-platform": { + "reftests": { + "canvas_clear.html": [ + "86a3da939dbe94efbeec04e5d366a40736ca4560", + [ + null, + [ + [ + "/_webgpu/webgpu/webgpu/web-platform/reftests/ref/canvas_clear-ref.html", + "==" + ] + ], + {} + ] + ], + "canvas_complex_bgra8unorm.html": [ + "1310543648e4fd640b0deb227000731af7b88b00", + [ + null, + [ + [ + "/_webgpu/webgpu/webgpu/web-platform/reftests/ref/canvas_complex-ref.html", + "==" + ] + ], + {} + ] + ] + } + } + } + } + }, + "support": { + "LICENSE.txt": [ + "c7a75d7d221561df02c42470ad5e751324de645d", + [] + ], + "README.md": [ + "ef0dbfee60ce3e787131ca40e5be64952e578e03", + [] + ], + "webgpu": { + "common": { + "framework": { + "file_loader.js": [ + "b6f3d50859515c47f8a9bdf2f2a9c6158fe104e0", + [] + ], + "fixture.js": [ + "191e2fc42d98ad2c2dce06adf7414e6d0c1e042d", + [] + ], + "glsl.js": [ + "7571416d886c2061245e262fcd06c45534472232", + [] + ], + "gpu": { + "device_pool.js": [ + "c6be73f9918be979816bf02978e8429ce8b4d63d", + [] + ], + "implementation.js": [ + "ab118a45444d120e521fbbd3e79d326b0a43beff", + [] + ] + }, + "logging": { + "log_message.js": [ + "8c1007fa822ddfc2a894540ad9ed041db298b972", + [] + ], + "logger.js": [ + "c4e65c746f04e3dfcb8ef2ed4053bef10250f958", + [] + ], + "result.js": [ + "d387dc3e340863c31f6f92d15083544021f7e4c7", + [] + ], + "test_case_recorder.js": [ + "37acb53143c22e9859eb94e1d059916b52274941", + [] + ] + }, + "params_builder.js": [ + "ab548de07844b48af7a54e08cd0dab676f2f5ba6", + [] + ], + "params_utils.js": [ + "a95d01b9c8058076af5cf49d4ab82b5c74367a5b", + [] + ], + "query": { + "compare.js": [ + "782088752f9cf68d4b7528cd42c72bc084380be3", + [] + ], + "encode_selectively.js": [ + "c621808e284ae6315e921b96f75f3cae10d78eb0", + [] + ], + "parseQuery.js": [ + "5a438c2bbb0beed622c030cc6748bd5c394ea2dd", + [] + ], + "query.js": [ + "0a9742055eb29f987958c1cc4d66a1cf4910f74b", + [] + ], + "separators.js": [ + "8fbaebdf945aaf95301b4d4e213659c152e1b6bc", + [] + ], + "stringify_params.js": [ + "931c5534f6172c801b39d9e24c05e4ef4e8d8938", + [] + ], + "validQueryPart.js": [ + "ca21627975fc498f2bff550c9a4e9d064c23af38", + [] + ] + }, + "test_group.js": [ + "4515bca19b70a701b2c32f2894b61b330d8e95ba", + [] + ], + "test_suite_listing.js": [ + "d387dc3e340863c31f6f92d15083544021f7e4c7", + [] + ], + "tree.js": [ + "87ff0d227e169c75255e0738af90946716f20134", + [] + ], + "util": { + "async_mutex.js": [ + "da461048fc495b118def36bff846e02be4268346", + [] + ], + "collect_garbage.js": [ + "d18982a2758e46634995ce7ac692918a0620a800", + [] + ], + "stack.js": [ + "00d08642d1534ea678f101c6d1627c5265df76bc", + [] + ], + "timeout.js": [ + "db1e5cfa1ae71e8c7fded6655b388441f4f851da", + [] + ], + "util.js": [ + "e7479046bee2e30f1116c1ab9f7d1e19ea6d82b4", + [] + ] + }, + "version.js": [ + "de50e581c26d8d5f2b6e91da39571cd8b21f1591", + [] + ] + }, + "runtime": { + "helper": { + "options.js": [ + "e70671a56319af57068da4c201c4868822da4564", + [] + ], + "test_worker-worker.js": [ + "2402c6c3ab7b978e1e093cc20be9c8cef75b9ca8", + [] + ], + "test_worker.js": [ + "f844920b50dc80340430cf0f42e54369d557a6ca", + [] + ] + }, + "wpt.js": [ + "5749159538dc7c08dd98f6b966054e2695d77437", + [] + ] + } + }, + "webgpu": { + "api": { + "operation": { + "buffers": { + "create_mapped.spec.js": [ + "0f950439b9d272d36b93bd76208af9461105f9fd", + [] + ], + "map.spec.js": [ + "19e1a2cc7c5c54a2e37c85dad35cc4fcfb8ac321", + [] + ], + "map_detach.spec.js": [ + "61f2d7aa9fbadaa6b6d2810314ec6b6c20f3f99d", + [] + ], + "map_oom.spec.js": [ + "f80fa767c08c5642c1add2612ac9895b16d1de19", + [] + ], + "mapping_test.js": [ + "ad2be711d40a44f2b64a5f5c27ab5d32afee24a4", + [] + ] + }, + "command_buffer": { + "basic.spec.js": [ + "7f4dd29b24ff8280b7aaede344b42bb5edca4d19", + [] + ], + "compute": { + "basic.spec.js": [ + "865601f869bac456d5de6678c75bc21fa8b3c722", + [] + ] + }, + "copies.spec.js": [ + "29d0bd58ee9c9cfdc8e244a7fbef0585c564b7f8", + [] + ], + "render": { + "basic.spec.js": [ + "d3913ef5752b277c62e4f451923231c6d55ff947", + [] + ], + "rendering.spec.js": [ + "60e843a6973fa1b84e6eddf9c5a2308d1f848141", + [] + ], + "storeop.spec.js": [ + "cd0c9d6145e11e0046f8ea6bb001f9518c972601", + [] + ] + } + }, + "fences.spec.js": [ + "98f913008b8af33e1dc866f5714388d4ec9e050d", + [] + ], + "render_pass": { + "storeOp.spec.js": [ + "678a462925021a32db5d33baa33701259bcf7d7c", + [] + ] + }, + "render_pipeline": { + "culling_tests.spec.js": [ + "a10a987520d089208b5aa49f3c329533188b379c", + [] + ] + }, + "resource_init": { + "copied_texture_clear.spec.js": [ + "28fb5b368e317ef68ba6a3ec854729c3ca8cfb0e", + [] + ], + "depth_stencil_attachment_clear.spec.js": [ + "06004eadf3486eb59ccdc0588a7982ea3275d68c", + [] + ], + "sampled_texture_clear.spec.js": [ + "5ee102a37ffcda076fc001a4e15db176b07fe4d3", + [] + ], + "texture_zero_init_test.js": [ + "e3c21011bb288492bd137be9e2e43b5efd02aa36", + [] + ] + } + }, + "validation": { + "createBindGroup.spec.js": [ + "fa585038e39ff6208787ee89bc177bdb13cdc385", + [] + ], + "createBindGroupLayout.spec.js": [ + "778ca6fb1b71e7f611722e0d90ce816bb062b90e", + [] + ], + "createPipelineLayout.spec.js": [ + "689ddaec883cd639f6cf94ab4d3005a4c4512db5", + [] + ], + "createRenderPipeline.spec.js": [ + "4a72faacd6c09555c3c1dac8424513f7b33a8c64", + [] + ], + "createTexture.spec.js": [ + "a9c7a8be01e03bcda1aa2f96374c30c0ce0bbe45", + [] + ], + "createView.spec.js": [ + "d5b16563c13d9429bb1da58b9c5dd18279904f3d", + [] + ], + "encoding": { + "cmds": { + "index_access.spec.js": [ + "b0eb5c7bc6cfcdf4479a6365b8b54c362424a696", + [] + ] + } + }, + "error_scope.spec.js": [ + "5523237daeba5d0c1c292dd3da8dead86a99f8e4", + [] + ], + "fences.spec.js": [ + "e2d4c7eb92220c98411c7e8f72be718c261a78b9", + [] + ], + "queue_submit.spec.js": [ + "2860a4f53188e1cc02774f0635c70962ecf9e52e", + [] + ], + "render_pass": { + "storeOp.spec.js": [ + "c43c6547bc8f268af93031db7173185768f6d2b3", + [] + ] + }, + "render_pass.spec.js": [ + "b9db03bc86f19fd1ad5c847153cfcc6399f0450b", + [] + ], + "render_pass_descriptor.spec.js": [ + "6b2b8c54b784620b65d213b9cddf4b803fbeba3a", + [] + ], + "setBindGroup.spec.js": [ + "fca85a83b0e5cf94d7950139c021ca6954e0e2ad", + [] + ], + "setBlendColor.spec.js": [ + "8a302fffd9807b5bf8ae1b6540f9af1b7c4425b8", + [] + ], + "setScissorRect.spec.js": [ + "7934c007286c8c4e9702eaaadb14b288a78e8fb1", + [] + ], + "setStencilReference.spec.js": [ + "f79a24044952c705004d254c81c31fd60967c54e", + [] + ], + "setVertexBuffer.spec.js": [ + "a7a173991eb3ff786af945af19e0e35ac56fc624", + [] + ], + "setViewport.spec.js": [ + "e2ef691b821825b9fa3c9fa5072dc734ec34d236", + [] + ], + "validation_test.js": [ + "d816fd0594bd5097f4a7e3d2de91c3e0aa6e3f7b", + [] + ], + "vertex_state.spec.js": [ + "7a30e3a013aeada0469fa8d85c69c14c26921dbb", + [] + ] + } + }, + "capability_info.js": [ + "df73575693bdf29f824ce6aeb144ec062aa2fb36", + [] + ], + "examples.spec.js": [ + "0d741fec3c2917808a885fa9a76a0300003c5382", + [] + ], + "gpu_test.js": [ + "a0163bb3ef38fe73f75b673f1507d92cc280b032", + [] + ], + "idl": { + "constants": { + "flags.spec.js": [ + "1de75c84e5daeaafd3ac47b31b6011223b03e360", + [] + ] + }, + "idl_test.js": [ + "231fc0945f87fe6aede03ec7a03c1ecaf7fe04db", + [] + ] + }, + "listing.js": [ + "51bba64a493acad8c8f0bbc515fb621ef538b839", + [] + ], + "shader": { + "execution": { + "robust_access.spec.js": [ + "0fe4a36ad10ee86a945a0546daac568882884fda", + [] + ], + "robust_access_vertex.spec.js": [ + "05b83fd049c98e4902096b467cf9f0aaa3fb4d51", + [] + ] + } + }, + "util": { + "conversion.js": [ + "bdba99cf7619ec4d66a5890f5566f68bbc6ed82d", + [] + ], + "math.js": [ + "a76f1a00158ab50df82c74187de859dfbef41d60", + [] + ], + "texture": { + "layout.js": [ + "cb9a883bd805e23b0c1769e78844fafd8717585f", + [] + ], + "subresource.js": [ + "889fab16e61f6b811d7475a4b5eb7c56353a8a91", + [] + ], + "texelData.js": [ + "8a827c47d21e1c1a89e081b2e70d1759c9208b0e", + [] + ] + } + }, + "web-platform": { + "canvas": { + "context_creation.spec.js": [ + "26dc5d8ab6787c628c820f42e43e33603e4cebff", + [] + ] + }, + "copyImageBitmapToTexture.spec.js": [ + "b37e311d280f2d3cea3d85767075cc51f3f2a124", + [] + ], + "reftests": { + "canvas_clear.js": [ + "a9149f039424546a9822d090b979fef921fe79c1", + [] + ], + "canvas_complex.js": [ + "e1aa3a25f88d26abdd381db249b03a6e84421fd5", + [] + ], + "gpu_ref_test.js": [ + "dd58b543b01ec86c1a820d9d661a5c3f9b68b323", + [] + ], + "ref": { + "canvas_clear-ref.html": [ + "2e0781186273ac49d6c70b5e5a9c68103aa5f173", + [] + ], + "canvas_complex-ref.html": [ + "3d5b3b3376d23cfdcda57f0c53fc3192e8a77bb6", + [] + ] + } + } + } + } + } + }, + "testharness": { + "webgpu": { + "cts.html": [ + "ea93cd81ce10e23a272a10bcbc0914644ef39cc9", + [ + "webgpu/cts.html?q=webgpu:api,operation,buffers,create_mapped:*", + {} + ], + [ + "webgpu/cts.html?q=webgpu:api,operation,buffers,map:*", + {} + ], + [ + "webgpu/cts.html?q=webgpu:api,operation,buffers,map_detach:*", + {} + ], + [ + "webgpu/cts.html?q=webgpu:api,operation,buffers,map_oom:*", + {} + ], + [ + "webgpu/cts.html?q=webgpu:api,operation,command_buffer,basic:*", + {} + ], + [ + "webgpu/cts.html?q=webgpu:api,operation,command_buffer,compute,basic:*", + {} + ], + [ + "webgpu/cts.html?q=webgpu:api,operation,command_buffer,copies:*", + {} + ], + [ + "webgpu/cts.html?q=webgpu:api,operation,command_buffer,render,basic:*", + {} + ], + [ + "webgpu/cts.html?q=webgpu:api,operation,command_buffer,render,rendering:*", + {} + ], + [ + "webgpu/cts.html?q=webgpu:api,operation,command_buffer,render,storeop:*", + {} + ], + [ + "webgpu/cts.html?q=webgpu:api,operation,fences:*", + {} + ], + [ + "webgpu/cts.html?q=webgpu:api,operation,render_pass,storeOp:*", + {} + ], + [ + "webgpu/cts.html?q=webgpu:api,operation,render_pipeline,culling_tests:*", + {} + ], + [ + "webgpu/cts.html?q=webgpu:api,operation,resource_init,copied_texture_clear:*", + {} + ], + [ + "webgpu/cts.html?q=webgpu:api,operation,resource_init,depth_stencil_attachment_clear:*", + {} + ], + [ + "webgpu/cts.html?q=webgpu:api,operation,resource_init,sampled_texture_clear:*", + {} + ], + [ + "webgpu/cts.html?q=webgpu:api,validation,createBindGroup:*", + {} + ], + [ + "webgpu/cts.html?q=webgpu:api,validation,createBindGroupLayout:*", + {} + ], + [ + "webgpu/cts.html?q=webgpu:api,validation,createPipelineLayout:*", + {} + ], + [ + "webgpu/cts.html?q=webgpu:api,validation,createRenderPipeline:*", + {} + ], + [ + "webgpu/cts.html?q=webgpu:api,validation,createTexture:*", + {} + ], + [ + "webgpu/cts.html?q=webgpu:api,validation,createView:*", + {} + ], + [ + "webgpu/cts.html?q=webgpu:api,validation,encoding,cmds,index_access:*", + {} + ], + [ + "webgpu/cts.html?q=webgpu:api,validation,error_scope:*", + {} + ], + [ + "webgpu/cts.html?q=webgpu:api,validation,fences:*", + {} + ], + [ + "webgpu/cts.html?q=webgpu:api,validation,queue_submit:*", + {} + ], + [ + "webgpu/cts.html?q=webgpu:api,validation,render_pass,storeOp:*", + {} + ], + [ + "webgpu/cts.html?q=webgpu:api,validation,render_pass:*", + {} + ], + [ + "webgpu/cts.html?q=webgpu:api,validation,render_pass_descriptor:*", + {} + ], + [ + "webgpu/cts.html?q=webgpu:api,validation,setBindGroup:*", + {} + ], + [ + "webgpu/cts.html?q=webgpu:api,validation,setBlendColor:*", + {} + ], + [ + "webgpu/cts.html?q=webgpu:api,validation,setScissorRect:*", + {} + ], + [ + "webgpu/cts.html?q=webgpu:api,validation,setStencilReference:*", + {} + ], + [ + "webgpu/cts.html?q=webgpu:api,validation,setVertexBuffer:*", + {} + ], + [ + "webgpu/cts.html?q=webgpu:api,validation,setViewport:*", + {} + ], + [ + "webgpu/cts.html?q=webgpu:api,validation,vertex_state:*", + {} + ], + [ + "webgpu/cts.html?q=webgpu:examples:*", + {} + ], + [ + "webgpu/cts.html?q=webgpu:idl,constants,flags:*", + {} + ], + [ + "webgpu/cts.html?q=webgpu:shader,execution,robust_access:*", + {} + ], + [ + "webgpu/cts.html?q=webgpu:shader,execution,robust_access_vertex:*", + {} + ], + [ + "webgpu/cts.html?q=webgpu:web-platform,canvas,context_creation:*", + {} + ], + [ + "webgpu/cts.html?q=webgpu:web-platform,copyImageBitmapToTexture:*", + {} + ] + ] + } + } + }, + "url_base": "/_webgpu/", + "version": 8 +} diff --git a/tests/wpt/webgpu/tests/LICENSE.txt b/tests/wpt/webgpu/tests/LICENSE.txt new file mode 100644 index 00000000000..c7a75d7d221 --- /dev/null +++ b/tests/wpt/webgpu/tests/LICENSE.txt @@ -0,0 +1,26 @@ +Copyright 2019 WebGPU CTS Contributors + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions of source code must retain the above copyright notice, + this list of conditions and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + 3. Neither the name of the copyright holder nor the names of its + contributors may be used to endorse or promote products derived from this + software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/tests/wpt/webgpu/tests/README.md b/tests/wpt/webgpu/tests/README.md new file mode 100644 index 00000000000..ef0dbfee60c --- /dev/null +++ b/tests/wpt/webgpu/tests/README.md @@ -0,0 +1,10 @@ +# WebGPU Conformance Test Suite + +The WebGPU CTS requires support for the WebGPU API. This requires both browser +support and hardware support, so this API cannot run on most automated testing +infrastructure. Tests inside this directory should always be skipped if +appropriate GPU hardware is not available. + +The contents of this directory are automatically generated from TypeScript +sources which live upstream in the [WebGPU CTS](https://github.com/gpuweb/cts). +They are periodically built and pushed to WPT. diff --git a/tests/wpt/webgpu/tests/webgpu/common/framework/file_loader.js b/tests/wpt/webgpu/tests/webgpu/common/framework/file_loader.js new file mode 100644 index 00000000000..b6f3d508595 --- /dev/null +++ b/tests/wpt/webgpu/tests/webgpu/common/framework/file_loader.js @@ -0,0 +1,39 @@ +/** + * AUTO-GENERATED - DO NOT EDIT. Source: https://github.com/gpuweb/cts + **/ import { parseQuery } from './query/parseQuery.js'; + +import { loadTreeForQuery } from './tree.js'; + +// A listing file, e.g. either of: +// - `src/webgpu/listing.ts` (which is dynamically computed, has a Promise) +// - `out/webgpu/listing.js` (which is pre-baked, has a TestSuiteListing) + +// Base class for DefaultTestFileLoader and FakeTestFileLoader. +export class TestFileLoader { + importSpecFile(suite, path) { + return this.import(`${suite}/${path.join('/')}.spec.js`); + } + + async loadTree(query, subqueriesToExpand = []) { + return loadTreeForQuery( + this, + query, + subqueriesToExpand.map(q => parseQuery(q)) + ); + } + + async loadCases(query) { + const tree = await this.loadTree(query); + return tree.iterateLeaves(); + } +} + +export class DefaultTestFileLoader extends TestFileLoader { + async listing(suite) { + return (await import(`../../${suite}/listing.js`)).listing; + } + + import(path) { + return import(`../../${path}`); + } +} diff --git a/tests/wpt/webgpu/tests/webgpu/common/framework/fixture.js b/tests/wpt/webgpu/tests/webgpu/common/framework/fixture.js new file mode 100644 index 00000000000..191e2fc42d9 --- /dev/null +++ b/tests/wpt/webgpu/tests/webgpu/common/framework/fixture.js @@ -0,0 +1,124 @@ +/** + * AUTO-GENERATED - DO NOT EDIT. Source: https://github.com/gpuweb/cts + **/ function _defineProperty(obj, key, value) { + if (key in obj) { + Object.defineProperty(obj, key, { + value: value, + enumerable: true, + configurable: true, + writable: true, + }); + } else { + obj[key] = value; + } + return obj; +} +import { assert } from './util/util.js'; + +export class SkipTestCase extends Error {} + +// A Fixture is a class used to instantiate each test case at run time. +// A new instance of the Fixture is created for every single test case +// (i.e. every time the test function is run). +export class Fixture { + constructor(rec, params) { + _defineProperty(this, 'params', void 0); + _defineProperty(this, 'rec', void 0); + _defineProperty(this, 'eventualExpectations', []); + _defineProperty(this, 'numOutstandingAsyncExpectations', 0); + this.rec = rec; + this.params = params; + } + + // This has to be a member function instead of an async `createFixture` function, because + // we need to be able to ergonomically override it in subclasses. + async init() {} + + debug(msg) { + this.rec.debug(new Error(msg)); + } + + skip(msg) { + throw new SkipTestCase(msg); + } + + async finalize() { + assert( + this.numOutstandingAsyncExpectations === 0, + 'there were outstanding asynchronous expectations (e.g. shouldReject) at the end of the test' + ); + + await Promise.all(this.eventualExpectations); + } + + warn(msg) { + this.rec.warn(new Error(msg)); + } + + fail(msg) { + this.rec.expectationFailed(new Error(msg)); + } + + async immediateAsyncExpectation(fn) { + this.numOutstandingAsyncExpectations++; + const ret = await fn(); + this.numOutstandingAsyncExpectations--; + return ret; + } + + eventualAsyncExpectation(fn) { + const promise = fn(new Error()); + this.eventualExpectations.push(promise); + return promise; + } + + expectErrorValue(expectedName, ex, niceStack) { + if (!(ex instanceof Error)) { + niceStack.message = `THREW non-error value, of type ${typeof ex}: ${ex}`; + this.rec.expectationFailed(niceStack); + return; + } + const actualName = ex.name; + if (actualName !== expectedName) { + niceStack.message = `THREW ${actualName}, instead of ${expectedName}: ${ex}`; + this.rec.expectationFailed(niceStack); + } else { + niceStack.message = `OK: threw ${actualName}${ex.message}`; + this.rec.debug(niceStack); + } + } + + shouldReject(expectedName, p, msg) { + this.eventualAsyncExpectation(async niceStack => { + const m = msg ? ': ' + msg : ''; + try { + await p; + niceStack.message = 'DID NOT REJECT' + m; + this.rec.expectationFailed(niceStack); + } catch (ex) { + niceStack.message = m; + this.expectErrorValue(expectedName, ex, niceStack); + } + }); + } + + shouldThrow(expectedName, fn, msg) { + const m = msg ? ': ' + msg : ''; + try { + fn(); + this.rec.expectationFailed(new Error('DID NOT THROW' + m)); + } catch (ex) { + this.expectErrorValue(expectedName, ex, new Error(m)); + } + } + + expect(cond, msg) { + if (cond) { + const m = msg ? ': ' + msg : ''; + this.rec.debug(new Error('expect OK' + m)); + } else { + this.rec.expectationFailed(new Error(msg)); + } + return cond; + } +} diff --git a/tests/wpt/webgpu/tests/webgpu/common/framework/glsl.js b/tests/wpt/webgpu/tests/webgpu/common/framework/glsl.js new file mode 100644 index 00000000000..7571416d886 --- /dev/null +++ b/tests/wpt/webgpu/tests/webgpu/common/framework/glsl.js @@ -0,0 +1,33 @@ +/** + * AUTO-GENERATED - DO NOT EDIT. Source: https://github.com/gpuweb/cts + **/ import { assert, unreachable } from './util/util.js'; + +let glslangAttempted = false; +let glslangInstance; + +export async function initGLSL() { + if (glslangAttempted) { + assert(glslangInstance !== undefined, 'glslang is not available'); + } else { + glslangAttempted = true; + const glslangPath = '../../third_party/glslang_js/lib/glslang.js'; + let glslangModule; + try { + glslangModule = (await import(glslangPath)).default; + } catch (ex) { + unreachable('glslang is not available'); + } + + const glslang = await glslangModule(); + glslangInstance = glslang; + } +} + +export function compileGLSL(glsl, shaderType, genDebug, spirvVersion) { + assert( + glslangInstance !== undefined, + 'GLSL compiler is not instantiated. Run `await initGLSL()` first' + ); + + return glslangInstance.compileGLSL(glsl.trimLeft(), shaderType, genDebug, spirvVersion); +} diff --git a/tests/wpt/webgpu/tests/webgpu/common/framework/gpu/device_pool.js b/tests/wpt/webgpu/tests/webgpu/common/framework/gpu/device_pool.js new file mode 100644 index 00000000000..c6be73f9918 --- /dev/null +++ b/tests/wpt/webgpu/tests/webgpu/common/framework/gpu/device_pool.js @@ -0,0 +1,152 @@ +/** + * AUTO-GENERATED - DO NOT EDIT. Source: https://github.com/gpuweb/cts + **/ function _defineProperty(obj, key, value) { + if (key in obj) { + Object.defineProperty(obj, key, { + value: value, + enumerable: true, + configurable: true, + writable: true, + }); + } else { + obj[key] = value; + } + return obj; +} +import { assert, raceWithRejectOnTimeout, unreachable, assertReject } from '../util/util.js'; +import { getGPU } from './implementation.js'; + +class TestFailedButDeviceReusable extends Error {} +export class TestOOMedShouldAttemptGC extends Error {} + +const kPopErrorScopeTimeoutMS = 5000; + +export class DevicePool { + constructor() { + _defineProperty(this, 'failed', false); + _defineProperty(this, 'holder', undefined); + } // undefined if "uninitialized" (not yet initialized, or lost) + + async acquire() { + assert(!this.failed, 'WebGPU device previously failed to initialize; not retrying'); + + if (this.holder === undefined) { + try { + this.holder = await DevicePool.makeHolder(); + } catch (ex) { + this.failed = true; + throw ex; + } + } + assert(!this.holder.acquired, 'Device was in use on DevicePool.acquire'); + this.holder.acquired = true; + + this.beginErrorScopes(); + return this.holder.device; + } + + // When a test is done using a device, it's released back into the pool. + // This waits for error scopes, checks their results, and checks for various error conditions. + async release(device) { + const holder = this.holder; + assert(holder !== undefined, 'trying to release a device while pool is uninitialized'); + assert(holder.acquired, 'trying to release a device while already released'); + assert(device === holder.device, 'Released device was the wrong device'); + + try { + // Time out if popErrorScope never completes. This could happen due to a browser bug - e.g., + // as of this writing, on Chrome GPU process crash, popErrorScope just hangs. + await raceWithRejectOnTimeout( + this.endErrorScopes(), + kPopErrorScopeTimeoutMS, + 'finalization popErrorScope timed out' + ); + + // (Hopefully if the device was lost, it has been reported by the time endErrorScopes() + // has finished (or timed out). If not, it could cause a finite number of extra test + // failures following this one (but should recover eventually).) + const lostReason = holder.lostReason; + if (lostReason !== undefined) { + // Fail the current test. + unreachable(`Device was lost: ${lostReason}`); + } + } catch (ex) { + // Any error that isn't explicitly TestFailedButDeviceReusable forces a new device to be + // created for the next test. + if (!(ex instanceof TestFailedButDeviceReusable)) { + this.holder = undefined; + } + throw ex; + } finally { + // TODO: device.destroy() + + // Mark the holder as free. (This only has an effect if the pool still has the holder.) + // This could be done at the top but is done here to guard against async-races during release. + holder.acquired = false; + } + } + + // Gets a device and creates a DeviceHolder. + // If the device is lost, DeviceHolder.lostReason gets set. + static async makeHolder() { + const gpu = getGPU(); + const adapter = await gpu.requestAdapter(); + + const holder = { + acquired: false, + device: await adapter.requestDevice(), + lostReason: undefined, + }; + + holder.device.lost.then(ev => { + holder.lostReason = ev.message; + }); + return holder; + } + + // Create error scopes that wrap the entire test. + beginErrorScopes() { + assert(this.holder !== undefined); + this.holder.device.pushErrorScope('out-of-memory'); + this.holder.device.pushErrorScope('validation'); + } + + // End the whole-test error scopes. Check that there are no extra error scopes, and that no + // otherwise-uncaptured errors occurred during the test. + async endErrorScopes() { + assert(this.holder !== undefined); + let gpuValidationError; + let gpuOutOfMemoryError; + + try { + // May reject if the device was lost. + gpuValidationError = await this.holder.device.popErrorScope(); + gpuOutOfMemoryError = await this.holder.device.popErrorScope(); + } catch (ex) { + assert( + this.holder.lostReason !== undefined, + "popErrorScope failed, but device.lost hasn't fired (yet)" + ); + + throw ex; + } + + await assertReject( + this.holder.device.popErrorScope(), + 'There was an extra error scope on the stack after a test' + ); + + if (gpuValidationError !== null) { + assert(gpuValidationError instanceof GPUValidationError); + // Allow the device to be reused. + throw new TestFailedButDeviceReusable( + `Unexpected validation error occurred: ${gpuValidationError.message}` + ); + } + if (gpuOutOfMemoryError !== null) { + assert(gpuOutOfMemoryError instanceof GPUOutOfMemoryError); + // Don't allow the device to be reused; unexpected OOM could break the device. + throw new TestOOMedShouldAttemptGC('Unexpected out-of-memory error occurred'); + } + } +} diff --git a/tests/wpt/webgpu/tests/webgpu/common/framework/gpu/implementation.js b/tests/wpt/webgpu/tests/webgpu/common/framework/gpu/implementation.js new file mode 100644 index 00000000000..ab118a45444 --- /dev/null +++ b/tests/wpt/webgpu/tests/webgpu/common/framework/gpu/implementation.js @@ -0,0 +1,19 @@ +/** + * AUTO-GENERATED - DO NOT EDIT. Source: https://github.com/gpuweb/cts + **/ /// +import { assert } from '../util/util.js'; +let impl = undefined; + +export function getGPU() { + if (impl) { + return impl; + } + + assert( + typeof navigator !== 'undefined' && navigator.gpu !== undefined, + 'No WebGPU implementation found' + ); + + impl = navigator.gpu; + return impl; +} diff --git a/tests/wpt/webgpu/tests/webgpu/common/framework/logging/log_message.js b/tests/wpt/webgpu/tests/webgpu/common/framework/logging/log_message.js new file mode 100644 index 00000000000..8c1007fa822 --- /dev/null +++ b/tests/wpt/webgpu/tests/webgpu/common/framework/logging/log_message.js @@ -0,0 +1,48 @@ +/** + * AUTO-GENERATED - DO NOT EDIT. Source: https://github.com/gpuweb/cts + **/ function _defineProperty(obj, key, value) { + if (key in obj) { + Object.defineProperty(obj, key, { + value: value, + enumerable: true, + configurable: true, + writable: true, + }); + } else { + obj[key] = value; + } + return obj; +} +import { extractImportantStackTrace } from '../util/stack.js'; +export class LogMessageWithStack extends Error { + constructor(name, ex) { + super(ex.message); + _defineProperty(this, 'stackHidden', false); + _defineProperty(this, 'timesSeen', 1); + + this.name = name; + this.stack = ex.stack; + } + + /** Set a flag so the stack is not printed in toJSON(). */ + setStackHidden() { + this.stackHidden = true; + } + + /** Increment the "seen x times" counter. */ + incrementTimesSeen() { + this.timesSeen++; + } + + toJSON() { + let m = this.name; + if (this.message) m += ': ' + this.message; + if (!this.stackHidden && this.stack) { + m += '\n' + extractImportantStackTrace(this); + } + if (this.timesSeen > 1) { + m += `\n(seen ${this.timesSeen} times with identical stack)`; + } + return m; + } +} diff --git a/tests/wpt/webgpu/tests/webgpu/common/framework/logging/logger.js b/tests/wpt/webgpu/tests/webgpu/common/framework/logging/logger.js new file mode 100644 index 00000000000..c4e65c746f0 --- /dev/null +++ b/tests/wpt/webgpu/tests/webgpu/common/framework/logging/logger.js @@ -0,0 +1,35 @@ +/** + * AUTO-GENERATED - DO NOT EDIT. Source: https://github.com/gpuweb/cts + **/ function _defineProperty(obj, key, value) { + if (key in obj) { + Object.defineProperty(obj, key, { + value: value, + enumerable: true, + configurable: true, + writable: true, + }); + } else { + obj[key] = value; + } + return obj; +} +import { version } from '../version.js'; +import { TestCaseRecorder } from './test_case_recorder.js'; + +export class Logger { + constructor(debug) { + _defineProperty(this, 'debug', void 0); + _defineProperty(this, 'results', new Map()); + this.debug = debug; + } + + record(name) { + const result = { status: 'running', timems: -1 }; + this.results.set(name, result); + return [new TestCaseRecorder(result, this.debug), result]; + } + + asJSON(space) { + return JSON.stringify({ version, results: Array.from(this.results) }, undefined, space); + } +} diff --git a/tests/wpt/webgpu/tests/webgpu/common/framework/logging/result.js b/tests/wpt/webgpu/tests/webgpu/common/framework/logging/result.js new file mode 100644 index 00000000000..d387dc3e340 --- /dev/null +++ b/tests/wpt/webgpu/tests/webgpu/common/framework/logging/result.js @@ -0,0 +1,3 @@ +/** + * AUTO-GENERATED - DO NOT EDIT. Source: https://github.com/gpuweb/cts + **/ diff --git a/tests/wpt/webgpu/tests/webgpu/common/framework/logging/test_case_recorder.js b/tests/wpt/webgpu/tests/webgpu/common/framework/logging/test_case_recorder.js new file mode 100644 index 00000000000..37acb53143c --- /dev/null +++ b/tests/wpt/webgpu/tests/webgpu/common/framework/logging/test_case_recorder.js @@ -0,0 +1,139 @@ +/** + * AUTO-GENERATED - DO NOT EDIT. Source: https://github.com/gpuweb/cts + **/ function _defineProperty(obj, key, value) { + if (key in obj) { + Object.defineProperty(obj, key, { + value: value, + enumerable: true, + configurable: true, + writable: true, + }); + } else { + obj[key] = value; + } + return obj; +} +import { SkipTestCase } from '../fixture.js'; +import { now, assert } from '../util/util.js'; +import { LogMessageWithStack } from './log_message.js'; +var LogSeverity; +(function (LogSeverity) { + LogSeverity[(LogSeverity['Pass'] = 0)] = 'Pass'; + LogSeverity[(LogSeverity['Skip'] = 1)] = 'Skip'; + LogSeverity[(LogSeverity['Warn'] = 2)] = 'Warn'; + LogSeverity[(LogSeverity['ExpectFailed'] = 3)] = 'ExpectFailed'; + LogSeverity[(LogSeverity['ValidationFailed'] = 4)] = 'ValidationFailed'; + LogSeverity[(LogSeverity['ThrewException'] = 5)] = 'ThrewException'; +})(LogSeverity || (LogSeverity = {})); + +const kMaxLogStacks = 2; + +/** Holds onto a LiveTestCaseResult owned by the Logger, and writes the results into it. */ +export class TestCaseRecorder { + /** Used to dedup log messages which have identical stacks. */ + + constructor(result, debugging) { + _defineProperty(this, 'result', void 0); + _defineProperty(this, 'maxLogSeverity', LogSeverity.Pass); + _defineProperty(this, 'startTime', -1); + _defineProperty(this, 'logs', []); + _defineProperty(this, 'logLinesAtCurrentSeverity', 0); + _defineProperty(this, 'debugging', false); + _defineProperty(this, 'messagesForPreviouslySeenStacks', new Map()); + this.result = result; + this.debugging = debugging; + } + + start() { + assert(this.startTime < 0, 'TestCaseRecorder cannot be reused'); + this.startTime = now(); + } + + finish() { + assert(this.startTime >= 0, 'finish() before start()'); + + const timeMilliseconds = now() - this.startTime; + // Round to next microsecond to avoid storing useless .xxxx00000000000002 in results. + this.result.timems = Math.ceil(timeMilliseconds * 1000) / 1000; + + // Convert numeric enum back to string (but expose 'exception' as 'fail') + this.result.status = + this.maxLogSeverity === LogSeverity.Pass + ? 'pass' + : this.maxLogSeverity === LogSeverity.Skip + ? 'skip' + : this.maxLogSeverity === LogSeverity.Warn + ? 'warn' + : 'fail'; // Everything else is an error + + this.result.logs = this.logs; + } + + injectResult(injectedResult) { + Object.assign(this.result, injectedResult); + } + + debug(ex) { + if (!this.debugging) { + return; + } + const logMessage = new LogMessageWithStack('DEBUG', ex); + logMessage.setStackHidden(); + this.logImpl(LogSeverity.Pass, logMessage); + } + + skipped(ex) { + this.logImpl(LogSeverity.Skip, new LogMessageWithStack('SKIP', ex)); + } + + warn(ex) { + this.logImpl(LogSeverity.Warn, new LogMessageWithStack('WARN', ex)); + } + + expectationFailed(ex) { + this.logImpl(LogSeverity.ExpectFailed, new LogMessageWithStack('EXPECTATION FAILED', ex)); + } + + validationFailed(ex) { + this.logImpl(LogSeverity.ValidationFailed, new LogMessageWithStack('VALIDATION FAILED', ex)); + } + + threw(ex) { + if (ex instanceof SkipTestCase) { + this.skipped(ex); + return; + } + this.logImpl(LogSeverity.ThrewException, new LogMessageWithStack('EXCEPTION', ex)); + } + + logImpl(level, logMessage) { + // Deduplicate errors with the exact same stack + if (logMessage.stack) { + const seen = this.messagesForPreviouslySeenStacks.get(logMessage.stack); + if (seen) { + seen.incrementTimesSeen(); + return; + } + this.messagesForPreviouslySeenStacks.set(logMessage.stack, logMessage); + } + + // Mark printStack=false for all logs except 2 at the highest severity + if (level > this.maxLogSeverity) { + this.logLinesAtCurrentSeverity = 0; + this.maxLogSeverity = level; + if (!this.debugging) { + // Go back and turn off printStack for everything of a lower log level + for (const log of this.logs) { + log.setStackHidden(); + } + } + } + if (level < this.maxLogSeverity || this.logLinesAtCurrentSeverity >= kMaxLogStacks) { + if (!this.debugging) { + logMessage.setStackHidden(); + } + } + this.logs.push(logMessage); + this.logLinesAtCurrentSeverity++; + } +} diff --git a/tests/wpt/webgpu/tests/webgpu/common/framework/params_builder.js b/tests/wpt/webgpu/tests/webgpu/common/framework/params_builder.js new file mode 100644 index 00000000000..ab548de0784 --- /dev/null +++ b/tests/wpt/webgpu/tests/webgpu/common/framework/params_builder.js @@ -0,0 +1,117 @@ +/** + * AUTO-GENERATED - DO NOT EDIT. Source: https://github.com/gpuweb/cts + **/ let _Symbol$iterator; +function _defineProperty(obj, key, value) { + if (key in obj) { + Object.defineProperty(obj, key, { + value: value, + enumerable: true, + configurable: true, + writable: true, + }); + } else { + obj[key] = value; + } + return obj; +} +import { publicParamsEquals } from './params_utils.js'; +import { assert } from './util/util.js'; +// https://stackoverflow.com/a/56375136 + +export function poptions(name, values) { + const iter = makeReusableIterable(function* () { + for (const value of values) { + yield { [name]: value }; + } + }); + + return iter; +} + +export function pbool(name) { + return poptions(name, [false, true]); +} + +export function params() { + return new ParamsBuilder(); +} +_Symbol$iterator = Symbol.iterator; +export class ParamsBuilder { + constructor() { + _defineProperty(this, 'paramSpecs', [{}]); + } + [_Symbol$iterator]() { + const iter = this.paramSpecs[Symbol.iterator](); + return iter; + } + + combine(newParams) { + const paramSpecs = this.paramSpecs; + this.paramSpecs = makeReusableIterable(function* () { + for (const a of paramSpecs) { + for (const b of newParams) { + yield mergeParams(a, b); + } + } + }); + + return this; + } + + expand(expander) { + const paramSpecs = this.paramSpecs; + this.paramSpecs = makeReusableIterable(function* () { + for (const a of paramSpecs) { + for (const b of expander(a)) { + yield mergeParams(a, b); + } + } + }); + + return this; + } + + filter(pred) { + const paramSpecs = this.paramSpecs; + this.paramSpecs = makeReusableIterable(function* () { + for (const p of paramSpecs) { + if (pred(p)) { + yield p; + } + } + }); + return this; + } + + unless(pred) { + return this.filter(x => !pred(x)); + } + + exclude(exclude) { + const excludeArray = Array.from(exclude); + const paramSpecs = this.paramSpecs; + this.paramSpecs = makeReusableIterable(function* () { + for (const p of paramSpecs) { + if (excludeArray.every(e => !publicParamsEquals(p, e))) { + yield p; + } + } + }); + return this; + } +} + +// If you create an Iterable by calling a generator function (e.g. in IIFE), it is exhausted after +// one use. This just wraps a generator function in an object so it be iterated multiple times. +function makeReusableIterable(generatorFn) { + return { [Symbol.iterator]: generatorFn }; +} + +// (keyof A & keyof B) is not empty, so they overlapped + +function mergeParams(a, b) { + for (const key of Object.keys(a)) { + assert(!(key in b), 'Duplicate key: ' + key); + } + return { ...a, ...b }; +} diff --git a/tests/wpt/webgpu/tests/webgpu/common/framework/params_utils.js b/tests/wpt/webgpu/tests/webgpu/common/framework/params_utils.js new file mode 100644 index 00000000000..a95d01b9c80 --- /dev/null +++ b/tests/wpt/webgpu/tests/webgpu/common/framework/params_utils.js @@ -0,0 +1,27 @@ +/** + * AUTO-GENERATED - DO NOT EDIT. Source: https://github.com/gpuweb/cts + **/ import { comparePublicParamsPaths, Ordering } from './query/compare.js'; +import { kWildcard, kParamSeparator, kParamKVSeparator } from './query/separators.js'; +// Consider adding more types here if needed + +export function paramKeyIsPublic(key) { + return !key.startsWith('_'); +} + +export function extractPublicParams(params) { + const publicParams = {}; + for (const k of Object.keys(params)) { + if (paramKeyIsPublic(k)) { + publicParams[k] = params[k]; + } + } + return publicParams; +} + +export const badParamValueChars = new RegExp( + '[' + kParamKVSeparator + kParamSeparator + kWildcard + ']' +); + +export function publicParamsEquals(x, y) { + return comparePublicParamsPaths(x, y) === Ordering.Equal; +} diff --git a/tests/wpt/webgpu/tests/webgpu/common/framework/query/compare.js b/tests/wpt/webgpu/tests/webgpu/common/framework/query/compare.js new file mode 100644 index 00000000000..782088752f9 --- /dev/null +++ b/tests/wpt/webgpu/tests/webgpu/common/framework/query/compare.js @@ -0,0 +1,93 @@ +/** + * AUTO-GENERATED - DO NOT EDIT. Source: https://github.com/gpuweb/cts + **/ import { paramKeyIsPublic } from '../params_utils.js'; +import { assert, objectEquals } from '../util/util.js'; + +export let Ordering; + +/** + * Compares two queries for their ordering (which is used to build the tree). + * + * See src/unittests/query_compare.spec.ts for examples. + */ (function (Ordering) { + Ordering[(Ordering['Unordered'] = 0)] = 'Unordered'; + Ordering[(Ordering['StrictSuperset'] = 1)] = 'StrictSuperset'; + Ordering[(Ordering['Equal'] = 2)] = 'Equal'; + Ordering[(Ordering['StrictSubset'] = 3)] = 'StrictSubset'; +})(Ordering || (Ordering = {})); +export function compareQueries(a, b) { + if (a.suite !== b.suite) { + return Ordering.Unordered; + } + + const filePathOrdering = comparePaths(a.filePathParts, b.filePathParts); + if (filePathOrdering !== Ordering.Equal || a.isMultiFile || b.isMultiFile) { + return compareOneLevel(filePathOrdering, a.isMultiFile, b.isMultiFile); + } + assert('testPathParts' in a && 'testPathParts' in b); + + const testPathOrdering = comparePaths(a.testPathParts, b.testPathParts); + if (testPathOrdering !== Ordering.Equal || a.isMultiTest || b.isMultiTest) { + return compareOneLevel(testPathOrdering, a.isMultiTest, b.isMultiTest); + } + assert('params' in a && 'params' in b); + + const paramsPathOrdering = comparePublicParamsPaths(a.params, b.params); + if (paramsPathOrdering !== Ordering.Equal || a.isMultiCase || b.isMultiCase) { + return compareOneLevel(paramsPathOrdering, a.isMultiCase, b.isMultiCase); + } + return Ordering.Equal; +} + +/** + * Compares a single level of a query. + * + * "IsBig" means the query is big relative to the level, e.g. for test-level: + * - Anything >= `suite:a,*` is big + * - Anything <= `suite:a:*` is small + */ +function compareOneLevel(ordering, aIsBig, bIsBig) { + assert(ordering !== Ordering.Equal || aIsBig || bIsBig); + if (ordering === Ordering.Unordered) return Ordering.Unordered; + if (aIsBig && bIsBig) return ordering; + if (!aIsBig && !bIsBig) return Ordering.Unordered; // Equal case is already handled + // Exactly one of (a, b) is big. + if (aIsBig && ordering !== Ordering.StrictSubset) return Ordering.StrictSuperset; + if (bIsBig && ordering !== Ordering.StrictSuperset) return Ordering.StrictSubset; + return Ordering.Unordered; +} + +function comparePaths(a, b) { + const shorter = Math.min(a.length, b.length); + + for (let i = 0; i < shorter; ++i) { + if (a[i] !== b[i]) { + return Ordering.Unordered; + } + } + if (a.length === b.length) { + return Ordering.Equal; + } else if (a.length < b.length) { + return Ordering.StrictSuperset; + } else { + return Ordering.StrictSubset; + } +} + +export function comparePublicParamsPaths(a, b) { + const aKeys = Object.keys(a).filter(k => paramKeyIsPublic(k)); + const commonKeys = new Set(aKeys.filter(k => k in b)); + + for (const k of commonKeys) { + if (!objectEquals(a[k], b[k])) { + return Ordering.Unordered; + } + } + const bKeys = Object.keys(b).filter(k => paramKeyIsPublic(k)); + const aRemainingKeys = aKeys.length - commonKeys.size; + const bRemainingKeys = bKeys.length - commonKeys.size; + if (aRemainingKeys === 0 && bRemainingKeys === 0) return Ordering.Equal; + if (aRemainingKeys === 0) return Ordering.StrictSuperset; + if (bRemainingKeys === 0) return Ordering.StrictSubset; + return Ordering.Unordered; +} diff --git a/tests/wpt/webgpu/tests/webgpu/common/framework/query/encode_selectively.js b/tests/wpt/webgpu/tests/webgpu/common/framework/query/encode_selectively.js new file mode 100644 index 00000000000..c621808e284 --- /dev/null +++ b/tests/wpt/webgpu/tests/webgpu/common/framework/query/encode_selectively.js @@ -0,0 +1,21 @@ +/** + * AUTO-GENERATED - DO NOT EDIT. Source: https://github.com/gpuweb/cts + **/ /** + * Encodes a stringified TestQuery so that it can be placed in a `?q=` parameter in a URL. + * + * `encodeURIComponent` encodes in accordance with `application/x-www-form-urlencoded`, + * but URLs don't actually have to be as strict as HTML form encoding + * (we interpret this purely from JavaScript). + * So we encode the component, then selectively convert some %-encoded escape codes + * back to their original form for readability/copyability. + */ export function encodeURIComponentSelectively(s) { + let ret = encodeURIComponent(s); + ret = ret.replace(/%22/g, '"'); // for JSON strings + ret = ret.replace(/%2C/g, ','); // for path separator, and JSON arrays + ret = ret.replace(/%3A/g, ':'); // for big separator + ret = ret.replace(/%3B/g, ';'); // for param separator + ret = ret.replace(/%3D/g, '='); // for params (k=v) + ret = ret.replace(/%5B/g, '['); // for JSON arrays + ret = ret.replace(/%5D/g, ']'); // for JSON arrays + return ret; +} diff --git a/tests/wpt/webgpu/tests/webgpu/common/framework/query/parseQuery.js b/tests/wpt/webgpu/tests/webgpu/common/framework/query/parseQuery.js new file mode 100644 index 00000000000..5a438c2bbb0 --- /dev/null +++ b/tests/wpt/webgpu/tests/webgpu/common/framework/query/parseQuery.js @@ -0,0 +1,128 @@ +/** + * AUTO-GENERATED - DO NOT EDIT. Source: https://github.com/gpuweb/cts + **/ import { badParamValueChars, paramKeyIsPublic } from '../params_utils.js'; +import { assert } from '../util/util.js'; + +import { + TestQueryMultiFile, + TestQueryMultiTest, + TestQueryMultiCase, + TestQuerySingleCase, +} from './query.js'; +import { kBigSeparator, kWildcard, kPathSeparator, kParamSeparator } from './separators.js'; +import { validQueryPart } from './validQueryPart.js'; + +export function parseQuery(s) { + try { + return parseQueryImpl(s); + } catch (ex) { + ex.message += '\n on: ' + s; + throw ex; + } +} + +function parseQueryImpl(s) { + // Undo encodeURIComponentSelectively + s = decodeURIComponent(s); + + // bigParts are: suite, group, test, params (note kBigSeparator could appear in params) + const [suite, fileString, testString, paramsString] = s.split(kBigSeparator, 4); + assert(fileString !== undefined, `filter string must have at least one ${kBigSeparator}`); + + const { parts: file, wildcard: filePathHasWildcard } = parseBigPart(fileString, kPathSeparator); + + if (testString === undefined) { + // Query is file-level + assert( + filePathHasWildcard, + `File-level query without wildcard ${kWildcard}. Did you want a file-level query \ +(append ${kPathSeparator}${kWildcard}) or test-level query (append ${kBigSeparator}${kWildcard})?` + ); + + return new TestQueryMultiFile(suite, file); + } + assert(!filePathHasWildcard, `Wildcard ${kWildcard} must be at the end of the query string`); + + const { parts: test, wildcard: testPathHasWildcard } = parseBigPart(testString, kPathSeparator); + + if (paramsString === undefined) { + // Query is test-level + assert( + testPathHasWildcard, + `Test-level query without wildcard ${kWildcard}; did you want a test-level query \ +(append ${kPathSeparator}${kWildcard}) or case-level query (append ${kBigSeparator}${kWildcard})?` + ); + + assert(file.length > 0, 'File part of test-level query was empty (::)'); + return new TestQueryMultiTest(suite, file, test); + } + + // Query is case-level + assert(!testPathHasWildcard, `Wildcard ${kWildcard} must be at the end of the query string`); + + const { parts: paramsParts, wildcard: paramsHasWildcard } = parseBigPart( + paramsString, + kParamSeparator + ); + + assert(test.length > 0, 'Test part of case-level query was empty (::)'); + + const params = {}; + for (const paramPart of paramsParts) { + const [k, v] = parseSingleParam(paramPart); + assert(validQueryPart.test(k), 'param key names must match ' + validQueryPart); + params[k] = v; + } + if (paramsHasWildcard) { + return new TestQueryMultiCase(suite, file, test, params); + } else { + return new TestQuerySingleCase(suite, file, test, params); + } +} + +// webgpu:a,b,* or webgpu:a,b,c:* +const kExampleQueries = `\ +webgpu${kBigSeparator}a${kPathSeparator}b${kPathSeparator}${kWildcard} or \ +webgpu${kBigSeparator}a${kPathSeparator}b${kPathSeparator}c${kBigSeparator}${kWildcard}`; + +function parseBigPart(s, separator) { + if (s === '') { + return { parts: [], wildcard: false }; + } + const parts = s.split(separator); + + let endsWithWildcard = false; + for (const [i, part] of parts.entries()) { + if (i === parts.length - 1) { + endsWithWildcard = part === kWildcard; + } + assert( + part.indexOf(kWildcard) === -1 || endsWithWildcard, + `Wildcard ${kWildcard} must be complete last part of a path (e.g. ${kExampleQueries})` + ); + } + if (endsWithWildcard) { + // Remove the last element of the array (which is just the wildcard). + parts.length = parts.length - 1; + } + return { parts, wildcard: endsWithWildcard }; +} + +function parseSingleParam(paramSubstring) { + assert(paramSubstring !== '', 'Param in a query must not be blank (is there a trailing comma?)'); + const i = paramSubstring.indexOf('='); + assert(i !== -1, 'Param in a query must be of form key=value'); + const k = paramSubstring.substring(0, i); + assert(paramKeyIsPublic(k), 'Param in a query must not be private (start with _)'); + const v = paramSubstring.substring(i + 1); + return [k, parseSingleParamValue(v)]; +} + +function parseSingleParamValue(s) { + assert( + !badParamValueChars.test(s), + `param value must not match ${badParamValueChars} - was ${s}` + ); + + return s === 'undefined' ? undefined : JSON.parse(s); +} diff --git a/tests/wpt/webgpu/tests/webgpu/common/framework/query/query.js b/tests/wpt/webgpu/tests/webgpu/common/framework/query/query.js new file mode 100644 index 00000000000..0a9742055eb --- /dev/null +++ b/tests/wpt/webgpu/tests/webgpu/common/framework/query/query.js @@ -0,0 +1,127 @@ +/** + * AUTO-GENERATED - DO NOT EDIT. Source: https://github.com/gpuweb/cts + **/ function _defineProperty(obj, key, value) { + if (key in obj) { + Object.defineProperty(obj, key, { + value: value, + enumerable: true, + configurable: true, + writable: true, + }); + } else { + obj[key] = value; + } + return obj; +} +import { assert } from '../util/util.js'; +import { encodeURIComponentSelectively } from './encode_selectively.js'; +import { kBigSeparator, kPathSeparator, kWildcard, kParamSeparator } from './separators.js'; +import { stringifyPublicParams } from './stringify_params.js'; + +/** + * Represents a test query of some level. + * + * TestQuery types are immutable. + */ + +// SingleCase + +/** + * A multi-file test query, like `s:*` or `s:a,b,*`. + * + * Immutable (makes copies of constructor args). + */ +export class TestQueryMultiFile { + constructor(suite, file) { + _defineProperty(this, 'level', 1); + _defineProperty(this, 'isMultiFile', true); + _defineProperty(this, 'suite', void 0); + _defineProperty(this, 'filePathParts', void 0); + this.suite = suite; + this.filePathParts = [...file]; + } + + toString() { + return encodeURIComponentSelectively(this.toStringHelper().join(kBigSeparator)); + } + + toStringHelper() { + return [this.suite, [...this.filePathParts, kWildcard].join(kPathSeparator)]; + } +} + +/** + * A multi-test test query, like `s:f:*` or `s:f:a,b,*`. + * + * Immutable (makes copies of constructor args). + */ +export class TestQueryMultiTest extends TestQueryMultiFile { + constructor(suite, file, test) { + super(suite, file); + _defineProperty(this, 'level', 2); + _defineProperty(this, 'isMultiFile', false); + _defineProperty(this, 'isMultiTest', true); + _defineProperty(this, 'testPathParts', void 0); + assert(file.length > 0, 'multi-test (or finer) query must have file-path'); + this.testPathParts = [...test]; + } + + toStringHelper() { + return [ + this.suite, + this.filePathParts.join(kPathSeparator), + [...this.testPathParts, kWildcard].join(kPathSeparator), + ]; + } +} + +/** + * A multi-case test query, like `s:f:t:*` or `s:f:t:a,b,*`. + * + * Immutable (makes copies of constructor args), except for param values + * (which aren't normally supposed to change; they're marked readonly in CaseParams). + */ +export class TestQueryMultiCase extends TestQueryMultiTest { + constructor(suite, file, test, params) { + super(suite, file, test); + _defineProperty(this, 'level', 3); + _defineProperty(this, 'isMultiTest', false); + _defineProperty(this, 'isMultiCase', true); + _defineProperty(this, 'params', void 0); + assert(test.length > 0, 'multi-case (or finer) query must have test-path'); + this.params = { ...params }; + } + + toStringHelper() { + const paramsParts = stringifyPublicParams(this.params); + return [ + this.suite, + this.filePathParts.join(kPathSeparator), + this.testPathParts.join(kPathSeparator), + [...paramsParts, kWildcard].join(kParamSeparator), + ]; + } +} + +/** + * A multi-case test query, like `s:f:t:` or `s:f:t:a=1,b=1`. + * + * Immutable (makes copies of constructor args). + */ +export class TestQuerySingleCase extends TestQueryMultiCase { + constructor(...args) { + super(...args); + _defineProperty(this, 'level', 4); + _defineProperty(this, 'isMultiCase', false); + } + + toStringHelper() { + const paramsParts = stringifyPublicParams(this.params); + return [ + this.suite, + this.filePathParts.join(kPathSeparator), + this.testPathParts.join(kPathSeparator), + paramsParts.join(kParamSeparator), + ]; + } +} diff --git a/tests/wpt/webgpu/tests/webgpu/common/framework/query/separators.js b/tests/wpt/webgpu/tests/webgpu/common/framework/query/separators.js new file mode 100644 index 00000000000..8fbaebdf945 --- /dev/null +++ b/tests/wpt/webgpu/tests/webgpu/common/framework/query/separators.js @@ -0,0 +1,14 @@ +/** + * AUTO-GENERATED - DO NOT EDIT. Source: https://github.com/gpuweb/cts + **/ /** Separator between big parts: suite:file:test:case */ export const kBigSeparator = ':'; +/** Separator between path,to,file or path,to,test */ +export const kPathSeparator = ','; + +/** Separator between k=v;k=v */ +export const kParamSeparator = ';'; + +/** Separator between key and value in k=v */ +export const kParamKVSeparator = '='; + +/** Final wildcard, if query is not single-case */ +export const kWildcard = '*'; diff --git a/tests/wpt/webgpu/tests/webgpu/common/framework/query/stringify_params.js b/tests/wpt/webgpu/tests/webgpu/common/framework/query/stringify_params.js new file mode 100644 index 00000000000..931c5534f61 --- /dev/null +++ b/tests/wpt/webgpu/tests/webgpu/common/framework/query/stringify_params.js @@ -0,0 +1,26 @@ +/** + * AUTO-GENERATED - DO NOT EDIT. Source: https://github.com/gpuweb/cts + **/ import { badParamValueChars, paramKeyIsPublic } from '../params_utils.js'; +import { assert } from '../util/util.js'; + +import { kParamKVSeparator } from './separators.js'; + +export function stringifyPublicParams(p) { + return Object.keys(p) + .filter(k => paramKeyIsPublic(k)) + .map(k => stringifySingleParam(k, p[k])); +} + +export function stringifySingleParam(k, v) { + return `${k}${kParamKVSeparator}${stringifySingleParamValue(v)}`; +} + +function stringifySingleParamValue(v) { + const s = v === undefined ? 'undefined' : JSON.stringify(v); + assert( + !badParamValueChars.test(s), + `JSON.stringified param value must not match ${badParamValueChars} - was ${s}` + ); + + return s; +} diff --git a/tests/wpt/webgpu/tests/webgpu/common/framework/query/validQueryPart.js b/tests/wpt/webgpu/tests/webgpu/common/framework/query/validQueryPart.js new file mode 100644 index 00000000000..ca21627975f --- /dev/null +++ b/tests/wpt/webgpu/tests/webgpu/common/framework/query/validQueryPart.js @@ -0,0 +1,3 @@ +/** + * AUTO-GENERATED - DO NOT EDIT. Source: https://github.com/gpuweb/cts + **/ /** Applies to group parts, test parts, params keys. */ export const validQueryPart = /^[a-zA-Z0-9_]+$/; diff --git a/tests/wpt/webgpu/tests/webgpu/common/framework/test_group.js b/tests/wpt/webgpu/tests/webgpu/common/framework/test_group.js new file mode 100644 index 00000000000..4515bca19b7 --- /dev/null +++ b/tests/wpt/webgpu/tests/webgpu/common/framework/test_group.js @@ -0,0 +1,162 @@ +/** + * AUTO-GENERATED - DO NOT EDIT. Source: https://github.com/gpuweb/cts + **/ function _defineProperty(obj, key, value) { + if (key in obj) { + Object.defineProperty(obj, key, { + value: value, + enumerable: true, + configurable: true, + writable: true, + }); + } else { + obj[key] = value; + } + return obj; +} +import { extractPublicParams, publicParamsEquals } from './params_utils.js'; +import { kPathSeparator } from './query/separators.js'; +import { stringifyPublicParams } from './query/stringify_params.js'; +import { validQueryPart } from './query/validQueryPart.js'; +import { assert } from './util/util.js'; + +export function makeTestGroup(fixture) { + return new TestGroup(fixture); +} + +// Interface for running tests + +export function makeTestGroupForUnitTesting(fixture) { + return new TestGroup(fixture); +} + +class TestGroup { + constructor(fixture) { + _defineProperty(this, 'fixture', void 0); + _defineProperty(this, 'seen', new Set()); + _defineProperty(this, 'tests', []); + this.fixture = fixture; + } + + *iterate() { + for (const test of this.tests) { + yield* test.iterate(); + } + } + + checkName(name) { + assert( + // Shouldn't happen due to the rule above. Just makes sure that treated + // unencoded strings as encoded strings is OK. + name === decodeURIComponent(name), + `Not decodeURIComponent-idempotent: ${name} !== ${decodeURIComponent(name)}` + ); + + assert(!this.seen.has(name), `Duplicate test name: ${name}`); + + this.seen.add(name); + } + + // TODO: This could take a fixture, too, to override the one for the group. + test(name) { + this.checkName(name); + + const parts = name.split(kPathSeparator); + for (const p of parts) { + assert(validQueryPart.test(p), `Invalid test name part ${p}; must match ${validQueryPart}`); + } + + const test = new TestBuilder(parts, this.fixture); + this.tests.push(test); + return test; + } + + checkCaseNamesAndDuplicates() { + for (const test of this.tests) { + test.checkCaseNamesAndDuplicates(); + } + } +} + +class TestBuilder { + constructor(testPath, fixture) { + _defineProperty(this, 'testPath', void 0); + _defineProperty(this, 'fixture', void 0); + _defineProperty(this, 'testFn', void 0); + _defineProperty(this, 'cases', undefined); + this.testPath = testPath; + this.fixture = fixture; + } + + fn(fn) { + this.testFn = fn; + } + + checkCaseNamesAndDuplicates() { + if (this.cases === undefined) { + return; + } + + // This is n^2. + const seen = []; + for (const testcase of this.cases) { + // stringifyPublicParams also checks for invalid params values + const testcaseString = stringifyPublicParams(testcase); + assert( + !seen.some(x => publicParamsEquals(x, testcase)), + `Duplicate public test case params: ${testcaseString}` + ); + + seen.push(testcase); + } + } + + params(casesIterable) { + assert(this.cases === undefined, 'test case is already parameterized'); + this.cases = Array.from(casesIterable); + + return this; + } + + *iterate() { + assert(this.testFn !== undefined, 'No test function (.fn()) for test'); + for (const params of this.cases || [{}]) { + yield new RunCaseSpecific(this.testPath, params, this.fixture, this.testFn); + } + } +} + +class RunCaseSpecific { + constructor(testPath, params, fixture, fn) { + _defineProperty(this, 'id', void 0); + _defineProperty(this, 'params', void 0); + _defineProperty(this, 'fixture', void 0); + _defineProperty(this, 'fn', void 0); + this.id = { test: testPath, params: extractPublicParams(params) }; + this.params = params; + this.fixture = fixture; + this.fn = fn; + } + + async run(rec) { + rec.start(); + try { + const inst = new this.fixture(rec, this.params || {}); + + try { + await inst.init(); + + await this.fn(inst); + } finally { + // Runs as long as constructor succeeded, even if initialization or the test failed. + await inst.finalize(); + } + } catch (ex) { + // There was an exception from constructor, init, test, or finalize. + // An error from init or test may have been a SkipTestCase. + // An error from finalize may have been an eventualAsyncExpectation failure + // or unexpected validation/OOM error from the GPUDevice. + rec.threw(ex); + } + rec.finish(); + } +} diff --git a/tests/wpt/webgpu/tests/webgpu/common/framework/test_suite_listing.js b/tests/wpt/webgpu/tests/webgpu/common/framework/test_suite_listing.js new file mode 100644 index 00000000000..d387dc3e340 --- /dev/null +++ b/tests/wpt/webgpu/tests/webgpu/common/framework/test_suite_listing.js @@ -0,0 +1,3 @@ +/** + * AUTO-GENERATED - DO NOT EDIT. Source: https://github.com/gpuweb/cts + **/ diff --git a/tests/wpt/webgpu/tests/webgpu/common/framework/tree.js b/tests/wpt/webgpu/tests/webgpu/common/framework/tree.js new file mode 100644 index 00000000000..87ff0d227e1 --- /dev/null +++ b/tests/wpt/webgpu/tests/webgpu/common/framework/tree.js @@ -0,0 +1,393 @@ +/** + * AUTO-GENERATED - DO NOT EDIT. Source: https://github.com/gpuweb/cts + **/ function _defineProperty(obj, key, value) { + if (key in obj) { + Object.defineProperty(obj, key, { + value: value, + enumerable: true, + configurable: true, + writable: true, + }); + } else { + obj[key] = value; + } + return obj; +} +import { compareQueries, Ordering } from './query/compare.js'; +import { + TestQueryMultiCase, + TestQuerySingleCase, + TestQueryMultiFile, + TestQueryMultiTest, +} from './query/query.js'; +import { kBigSeparator, kWildcard, kPathSeparator, kParamSeparator } from './query/separators.js'; +import { stringifySingleParam } from './query/stringify_params.js'; + +import { assert } from './util/util.js'; + +// `loadTreeForQuery()` loads a TestTree for a given queryToLoad. +// The resulting tree is a linked-list all the way from `suite:*` to queryToLoad, +// and under queryToLoad is a tree containing every case matched by queryToLoad. +// +// `subqueriesToExpand` influences the `collapsible` flag on nodes in the resulting tree. +// A node is considered "collapsible" if none of the subqueriesToExpand is a StrictSubset +// of that node. +// +// In WebKit/Blink-style web_tests, an expectation file marks individual cts.html "variants" as +// "Failure", "Crash", etc. +// By passing in the list of expectations as the subqueriesToExpand, we can programmatically +// subdivide the cts.html "variants" list to be able to implement arbitrarily-fine suppressions +// (instead of having to suppress entire test files, which would lose a lot of coverage). +// +// `iterateCollapsedQueries()` produces the list of queries for the variants list. +// +// Though somewhat complicated, this system has important benefits: +// - Avoids having to suppress entire test files, which would cause large test coverage loss. +// - Minimizes the number of page loads needed for fine-grained suppressions. +// (In the naive case, we could do one page load per test case - but the test suite would +// take impossibly long to run.) +// - Enables developers to put any number of tests in one file as appropriate, without worrying +// about expectation granularity. + +export class TestTree { + constructor(root) { + _defineProperty(this, 'root', void 0); + this.root = root; + } + + iterateCollapsedQueries() { + return TestTree.iterateSubtreeCollapsedQueries(this.root); + } + + iterateLeaves() { + return TestTree.iterateSubtreeLeaves(this.root); + } + + /** + * If a parent and its child are at different levels, then + * generally the parent has only one child, i.e.: + * a,* { a,b,* { a,b:* { ... } } } + * Collapse that down into: + * a,* { a,b:* { ... } } + * which is less needlessly verbose when displaying the tree in the standalone runner. + */ + dissolveLevelBoundaries() { + const newRoot = dissolveLevelBoundaries(this.root); + assert(newRoot === this.root); + } + + toString() { + return TestTree.subtreeToString('(root)', this.root, ''); + } + + static *iterateSubtreeCollapsedQueries(subtree) { + for (const [, child] of subtree.children) { + if ('children' in child && !child.collapsible) { + yield* TestTree.iterateSubtreeCollapsedQueries(child); + } else { + yield child.query; + } + } + } + + static *iterateSubtreeLeaves(subtree) { + for (const [, child] of subtree.children) { + if ('children' in child) { + yield* TestTree.iterateSubtreeLeaves(child); + } else { + yield child; + } + } + } + + static subtreeToString(name, tree, indent) { + const collapsible = 'run' in tree ? '>' : tree.collapsible ? '+' : '-'; + let s = indent + `${collapsible} ${JSON.stringify(name)} => ${tree.query}`; + if ('children' in tree) { + if (tree.description !== undefined) { + s += `\n${indent} | ${JSON.stringify(tree.description)}`; + } + + for (const [name, child] of tree.children) { + s += '\n' + TestTree.subtreeToString(name, child, indent + ' '); + } + } + return s; + } +} + +// TODO: Consider having subqueriesToExpand actually impact the depth-order of params in the tree. +export async function loadTreeForQuery(loader, queryToLoad, subqueriesToExpand) { + const suite = queryToLoad.suite; + const specs = await loader.listing(suite); + + const subqueriesToExpandEntries = Array.from(subqueriesToExpand.entries()); + const seenSubqueriesToExpand = new Array(subqueriesToExpand.length); + seenSubqueriesToExpand.fill(false); + + const isCollapsible = subquery => + subqueriesToExpandEntries.every(([i, toExpand]) => { + const ordering = compareQueries(toExpand, subquery); + + // If toExpand == subquery, no expansion is needed (but it's still "seen"). + if (ordering === Ordering.Equal) seenSubqueriesToExpand[i] = true; + return ordering !== Ordering.StrictSubset; + }); + + // L0 = suite-level, e.g. suite:* + // L1 = file-level, e.g. suite:a,b:* + // L2 = test-level, e.g. suite:a,b:c,d:* + // L3 = case-level, e.g. suite:a,b:c,d: + let foundCase = false; + // L0 is suite:* + const subtreeL0 = makeTreeForSuite(suite); + isCollapsible(subtreeL0.query); // mark seenSubqueriesToExpand + for (const entry of specs) { + if (entry.file.length === 0 && 'readme' in entry) { + // Suite-level readme. + assert(subtreeL0.description === undefined); + subtreeL0.description = entry.readme.trim(); + continue; + } + + { + const queryL1 = new TestQueryMultiFile(suite, entry.file); + const orderingL1 = compareQueries(queryL1, queryToLoad); + if (orderingL1 === Ordering.Unordered) { + // File path is not matched by this query. + continue; + } + } + + if ('readme' in entry) { + // Entry is a README that is an ancestor or descendant of the query. + // (It's included for display in the standalone runner.) + + // readmeSubtree is suite:a,b,* + // (This is always going to dedup with a file path, if there are any test spec files under + // the directory that has the README). + const readmeSubtree = addSubtreeForDirPath(subtreeL0, entry.file); + + assert(readmeSubtree.description === undefined); + readmeSubtree.description = entry.readme.trim(); + continue; + } + // Entry is a spec file. + + const spec = await loader.importSpecFile(queryToLoad.suite, entry.file); + const description = spec.description.trim(); + // subtreeL1 is suite:a,b:* + const subtreeL1 = addSubtreeForFilePath(subtreeL0, entry.file, description, isCollapsible); + + // TODO: If tree generation gets too slow, avoid actually iterating the cases in a file + // if there's no need to (based on the subqueriesToExpand). + for (const t of spec.g.iterate()) { + { + const queryL3 = new TestQuerySingleCase(suite, entry.file, t.id.test, t.id.params); + const orderingL3 = compareQueries(queryL3, queryToLoad); + if (orderingL3 === Ordering.Unordered || orderingL3 === Ordering.StrictSuperset) { + // Case is not matched by this query. + continue; + } + } + + // subtreeL2 is suite:a,b:c,d:* + const subtreeL2 = addSubtreeForTestPath(subtreeL1, t.id.test, isCollapsible); + + // Leaf for case is suite:a,b:c,d:x=1;y=2 + addLeafForCase(subtreeL2, t, isCollapsible); + + foundCase = true; + } + } + + for (const [i, sq] of subqueriesToExpandEntries) { + const seen = seenSubqueriesToExpand[i]; + assert( + seen, + `subqueriesToExpand entry did not match anything \ +(can happen due to overlap with another subquery): ${sq.toString()}` + ); + } + assert(foundCase, 'Query does not match any cases'); + + return new TestTree(subtreeL0); +} + +function makeTreeForSuite(suite) { + return { + readableRelativeName: suite + kBigSeparator, + query: new TestQueryMultiFile(suite, []), + children: new Map(), + collapsible: false, + }; +} + +function addSubtreeForDirPath(tree, file) { + const subqueryFile = []; + // To start, tree is suite:* + // This loop goes from that -> suite:a,* -> suite:a,b,* + for (const part of file) { + subqueryFile.push(part); + tree = getOrInsertSubtree(part, tree, () => { + const query = new TestQueryMultiFile(tree.query.suite, subqueryFile); + return { readableRelativeName: part + kPathSeparator + kWildcard, query, collapsible: false }; + }); + } + return tree; +} + +function addSubtreeForFilePath(tree, file, description, checkCollapsible) { + // To start, tree is suite:* + // This goes from that -> suite:a,* -> suite:a,b,* + tree = addSubtreeForDirPath(tree, file); + // This goes from that -> suite:a,b:* + const subtree = getOrInsertSubtree('', tree, () => { + const query = new TestQueryMultiTest(tree.query.suite, tree.query.filePathParts, []); + assert(file.length > 0, 'file path is empty'); + return { + readableRelativeName: file[file.length - 1] + kBigSeparator + kWildcard, + query, + description, + collapsible: checkCollapsible(query), + }; + }); + return subtree; +} + +function addSubtreeForTestPath(tree, test, isCollapsible) { + const subqueryTest = []; + // To start, tree is suite:a,b:* + // This loop goes from that -> suite:a,b:c,* -> suite:a,b:c,d,* + for (const part of test) { + subqueryTest.push(part); + tree = getOrInsertSubtree(part, tree, () => { + const query = new TestQueryMultiTest( + tree.query.suite, + tree.query.filePathParts, + subqueryTest + ); + + return { + readableRelativeName: part + kPathSeparator + kWildcard, + query, + collapsible: isCollapsible(query), + }; + }); + } + // This goes from that -> suite:a,b:c,d:* + return getOrInsertSubtree('', tree, () => { + const query = new TestQueryMultiCase( + tree.query.suite, + tree.query.filePathParts, + subqueryTest, + {} + ); + + assert(subqueryTest.length > 0, 'subqueryTest is empty'); + return { + readableRelativeName: subqueryTest[subqueryTest.length - 1] + kBigSeparator + kWildcard, + kWildcard, + query, + collapsible: isCollapsible(query), + }; + }); +} + +function addLeafForCase(tree, t, checkCollapsible) { + const query = tree.query; + let name = ''; + const subqueryParams = {}; + + // To start, tree is suite:a,b:c,d:* + // This loop goes from that -> suite:a,b:c,d:x=1;* -> suite:a,b:c,d:x=1;y=2;* + for (const [k, v] of Object.entries(t.id.params)) { + name = stringifySingleParam(k, v); + subqueryParams[k] = v; + + tree = getOrInsertSubtree(name, tree, () => { + const subquery = new TestQueryMultiCase( + query.suite, + query.filePathParts, + query.testPathParts, + subqueryParams + ); + + return { + readableRelativeName: name + kParamSeparator + kWildcard, + query: subquery, + collapsible: checkCollapsible(subquery), + }; + }); + } + + // This goes from that -> suite:a,b:c,d:x=1;y=2 + const subquery = new TestQuerySingleCase( + query.suite, + query.filePathParts, + query.testPathParts, + subqueryParams + ); + + checkCollapsible(subquery); // mark seenSubqueriesToExpand + insertLeaf(tree, subquery, t); +} + +function getOrInsertSubtree(key, parent, createSubtree) { + let v; + const child = parent.children.get(key); + if (child !== undefined) { + assert('children' in child); // Make sure cached subtree is not actually a leaf + v = child; + } else { + v = { ...createSubtree(), children: new Map() }; + parent.children.set(key, v); + } + return v; +} + +function insertLeaf(parent, query, t) { + const key = ''; + const leaf = { + readableRelativeName: readableNameForCase(query), + query, + run: rec => t.run(rec), + }; + + assert(!parent.children.has(key)); + parent.children.set(key, leaf); +} + +function dissolveLevelBoundaries(tree) { + if ('children' in tree) { + if (tree.children.size === 1 && tree.description === undefined) { + // Loops exactly once + for (const [, child] of tree.children) { + if (child.query.level > tree.query.level) { + const newtree = dissolveLevelBoundaries(child); + + return newtree; + } + } + } + + for (const [k, child] of tree.children) { + const newChild = dissolveLevelBoundaries(child); + if (newChild !== child) { + tree.children.set(k, newChild); + } + } + } + return tree; +} + +/** Generate a readable relative name for a case (used in standalone). */ +function readableNameForCase(query) { + const paramsKeys = Object.keys(query.params); + if (paramsKeys.length === 0) { + return query.testPathParts[query.testPathParts.length - 1] + kBigSeparator; + } else { + const lastKey = paramsKeys[paramsKeys.length - 1]; + return stringifySingleParam(lastKey, query.params[lastKey]); + } +} diff --git a/tests/wpt/webgpu/tests/webgpu/common/framework/util/async_mutex.js b/tests/wpt/webgpu/tests/webgpu/common/framework/util/async_mutex.js new file mode 100644 index 00000000000..da461048fc4 --- /dev/null +++ b/tests/wpt/webgpu/tests/webgpu/common/framework/util/async_mutex.js @@ -0,0 +1,38 @@ +/** + * AUTO-GENERATED - DO NOT EDIT. Source: https://github.com/gpuweb/cts + **/ function _defineProperty(obj, key, value) { + if (key in obj) { + Object.defineProperty(obj, key, { + value: value, + enumerable: true, + configurable: true, + writable: true, + }); + } else { + obj[key] = value; + } + return obj; +} +export class AsyncMutex { + constructor() { + _defineProperty(this, 'newestQueueItem', void 0); + } + + // Run an async function with a lock on this mutex. + // Waits until the mutex is available, locks it, runs the function, then releases it. + async with(fn) { + const p = (async () => { + // If the mutex is locked, wait for the last thing in the queue before running. + // (Everything in the queue runs in order, so this is after everything currently enqueued.) + if (this.newestQueueItem) { + await this.newestQueueItem; + } + return fn(); + })(); + + // Push the newly-created Promise onto the queue by replacing the old "newest" item. + this.newestQueueItem = p; + // And return so the caller can wait on the result. + return p; + } +} diff --git a/tests/wpt/webgpu/tests/webgpu/common/framework/util/collect_garbage.js b/tests/wpt/webgpu/tests/webgpu/common/framework/util/collect_garbage.js new file mode 100644 index 00000000000..d18982a2758 --- /dev/null +++ b/tests/wpt/webgpu/tests/webgpu/common/framework/util/collect_garbage.js @@ -0,0 +1,47 @@ +/** + * AUTO-GENERATED - DO NOT EDIT. Source: https://github.com/gpuweb/cts + **/ import { resolveOnTimeout } from './util.js'; + +export async function attemptGarbageCollection() { + const w = self; + if (w.GCController) { + w.GCController.collect(); + return; + } + + if (w.opera && w.opera.collect) { + w.opera.collect(); + return; + } + + try { + w.QueryInterface(Components.interfaces.nsIInterfaceRequestor) + .getInterface(Components.interfaces.nsIDOMWindowUtils) + .garbageCollect(); + return; + } catch (e) {} + + if (w.gc) { + w.gc(); + return; + } + + if (w.CollectGarbage) { + w.CollectGarbage(); + return; + } + + let i; + function gcRec(n) { + if (n < 1) return; + let temp = { i: 'ab' + i + i / 100000 }; + temp = temp + 'foo'; + temp; // dummy use of unused variable + gcRec(n - 1); + } + for (i = 0; i < 1000; i++) { + gcRec(10); + } + + return resolveOnTimeout(35); // Let the event loop run a few frames in case it helps. +} diff --git a/tests/wpt/webgpu/tests/webgpu/common/framework/util/stack.js b/tests/wpt/webgpu/tests/webgpu/common/framework/util/stack.js new file mode 100644 index 00000000000..00d08642d15 --- /dev/null +++ b/tests/wpt/webgpu/tests/webgpu/common/framework/util/stack.js @@ -0,0 +1,78 @@ +/** + * AUTO-GENERATED - DO NOT EDIT. Source: https://github.com/gpuweb/cts + **/ // Returns the stack trace of an Error, but without the extra boilerplate at the bottom +// (e.g. RunCaseSpecific, processTicksAndRejections, etc.), for logging. +export function extractImportantStackTrace(e) { + if (!e.stack) { + return ''; + } + const lines = e.stack.split('\n'); + for (let i = lines.length - 1; i >= 0; --i) { + const line = lines[i]; + if (line.indexOf('.spec.') !== -1) { + return lines.slice(0, i + 1).join('\n'); + } + } + return e.stack; +} + +// *** Examples *** +// +// Node fail() +// > Error: +// > at CaseRecorder.fail (/Users/kainino/src/cts/src/common/framework/logger.ts:99:30) +// > at RunCaseSpecific.exports.g.test.t [as fn] (/Users/kainino/src/cts/src/unittests/logger.spec.ts:80:7) +// x at RunCaseSpecific.run (/Users/kainino/src/cts/src/common/framework/test_group.ts:121:18) +// x at processTicksAndRejections (internal/process/task_queues.js:86:5) +// +// Node throw +// > Error: hello +// > at RunCaseSpecific.g.test.t [as fn] (/Users/kainino/src/cts/src/unittests/test_group.spec.ts:51:11) +// x at RunCaseSpecific.run (/Users/kainino/src/cts/src/common/framework/test_group.ts:121:18) +// x at processTicksAndRejections (internal/process/task_queues.js:86:5) +// +// Firefox fail() +// > fail@http://localhost:8080/out/framework/logger.js:104:30 +// > expect@http://localhost:8080/out/framework/default_fixture.js:59:16 +// > @http://localhost:8080/out/unittests/util.spec.js:35:5 +// x run@http://localhost:8080/out/framework/test_group.js:119:18 +// +// Firefox throw +// > @http://localhost:8080/out/unittests/test_group.spec.js:48:11 +// x run@http://localhost:8080/out/framework/test_group.js:119:18 +// +// Safari fail() +// > fail@http://localhost:8080/out/framework/logger.js:104:39 +// > expect@http://localhost:8080/out/framework/default_fixture.js:59:20 +// > http://localhost:8080/out/unittests/util.spec.js:35:11 +// x http://localhost:8080/out/framework/test_group.js:119:20 +// x asyncFunctionResume@[native code] +// x [native code] +// x promiseReactionJob@[native code] +// +// Safari throw +// > http://localhost:8080/out/unittests/test_group.spec.js:48:20 +// x http://localhost:8080/out/framework/test_group.js:119:20 +// x asyncFunctionResume@[native code] +// x [native code] +// x promiseReactionJob@[native code] +// +// Chrome fail() +// x Error +// x at CaseRecorder.fail (http://localhost:8080/out/framework/logger.js:104:30) +// x at DefaultFixture.expect (http://localhost:8080/out/framework/default_fixture.js:59:16) +// > at RunCaseSpecific.fn (http://localhost:8080/out/unittests/util.spec.js:35:5) +// x at RunCaseSpecific.run (http://localhost:8080/out/framework/test_group.js:119:18) +// x at async runCase (http://localhost:8080/out/runtime/standalone.js:37:17) +// x at async http://localhost:8080/out/runtime/standalone.js:102:7 +// +// Chrome throw +// x Error: hello +// > at RunCaseSpecific.fn (http://localhost:8080/out/unittests/test_group.spec.js:48:11) +// x at RunCaseSpecific.run (http://localhost:8080/out/framework/test_group.js:119:18)" +// x at async Promise.all (index 0) +// x at async TestGroupTest.run (http://localhost:8080/out/unittests/test_group_test.js:6:5) +// x at async RunCaseSpecific.fn (http://localhost:8080/out/unittests/test_group.spec.js:53:15) +// x at async RunCaseSpecific.run (http://localhost:8080/out/framework/test_group.js:119:7) +// x at async runCase (http://localhost:8080/out/runtime/standalone.js:37:17) +// x at async http://localhost:8080/out/runtime/standalone.js:102:7 diff --git a/tests/wpt/webgpu/tests/webgpu/common/framework/util/timeout.js b/tests/wpt/webgpu/tests/webgpu/common/framework/util/timeout.js new file mode 100644 index 00000000000..db1e5cfa1ae --- /dev/null +++ b/tests/wpt/webgpu/tests/webgpu/common/framework/util/timeout.js @@ -0,0 +1,3 @@ +/** + * AUTO-GENERATED - DO NOT EDIT. Source: https://github.com/gpuweb/cts + **/ export const timeout = typeof step_timeout !== 'undefined' ? step_timeout : setTimeout; diff --git a/tests/wpt/webgpu/tests/webgpu/common/framework/util/util.js b/tests/wpt/webgpu/tests/webgpu/common/framework/util/util.js new file mode 100644 index 00000000000..e7479046bee --- /dev/null +++ b/tests/wpt/webgpu/tests/webgpu/common/framework/util/util.js @@ -0,0 +1,72 @@ +/** + * AUTO-GENERATED - DO NOT EDIT. Source: https://github.com/gpuweb/cts + **/ import { timeout } from './timeout.js'; +export function assert(condition, msg) { + if (!condition) { + throw new Error(msg && (typeof msg === 'string' ? msg : msg())); + } +} + +export async function assertReject(p, msg) { + try { + await p; + unreachable(msg); + } catch (ex) { + // Assertion OK + } +} + +export function unreachable(msg) { + throw new Error(msg); +} + +// performance.now() is available in all browsers, but not in scope by default in Node. +const perf = typeof performance !== 'undefined' ? performance : require('perf_hooks').performance; + +export function now() { + return perf.now(); +} + +export function resolveOnTimeout(ms) { + return new Promise(resolve => { + timeout(() => { + resolve(); + }, ms); + }); +} + +export class PromiseTimeoutError extends Error {} + +export function rejectOnTimeout(ms, msg) { + return new Promise((_resolve, reject) => { + timeout(() => { + reject(new PromiseTimeoutError(msg)); + }, ms); + }); +} + +export function raceWithRejectOnTimeout(p, ms, msg) { + return Promise.race([p, rejectOnTimeout(ms, msg)]); +} + +export function objectEquals(x, y) { + if (typeof x !== 'object' || typeof y !== 'object') return x === y; + if (x === null || y === null) return x === y; + if (x.constructor !== y.constructor) return false; + if (x instanceof Function) return x === y; + if (x instanceof RegExp) return x === y; + if (x === y || x.valueOf() === y.valueOf()) return true; + if (Array.isArray(x) && Array.isArray(y) && x.length !== y.length) return false; + if (x instanceof Date) return false; + if (!(x instanceof Object)) return false; + if (!(y instanceof Object)) return false; + + const x1 = x; + const y1 = y; + const p = Object.keys(x); + return Object.keys(y).every(i => p.indexOf(i) !== -1) && p.every(i => objectEquals(x1[i], y1[i])); +} + +export function range(n, fn) { + return [...new Array(n)].map((_, i) => fn(i)); +} diff --git a/tests/wpt/webgpu/tests/webgpu/common/framework/version.js b/tests/wpt/webgpu/tests/webgpu/common/framework/version.js new file mode 100644 index 00000000000..de50e581c26 --- /dev/null +++ b/tests/wpt/webgpu/tests/webgpu/common/framework/version.js @@ -0,0 +1,3 @@ +// AUTO-GENERATED - DO NOT EDIT. See tools/gen_version. + +export const version = '474ff8e569a0d206f8cb6f6146a8769fadf77da9-dirty'; diff --git a/tests/wpt/webgpu/tests/webgpu/common/runtime/helper/options.js b/tests/wpt/webgpu/tests/webgpu/common/runtime/helper/options.js new file mode 100644 index 00000000000..e70671a5631 --- /dev/null +++ b/tests/wpt/webgpu/tests/webgpu/common/runtime/helper/options.js @@ -0,0 +1,7 @@ +/** + * AUTO-GENERATED - DO NOT EDIT. Source: https://github.com/gpuweb/cts + **/ const url = new URL(window.location.toString()); +export function optionEnabled(opt) { + const val = url.searchParams.get(opt); + return val !== null && val !== '0'; +} diff --git a/tests/wpt/webgpu/tests/webgpu/common/runtime/helper/test_worker-worker.js b/tests/wpt/webgpu/tests/webgpu/common/runtime/helper/test_worker-worker.js new file mode 100644 index 00000000000..2402c6c3ab7 --- /dev/null +++ b/tests/wpt/webgpu/tests/webgpu/common/runtime/helper/test_worker-worker.js @@ -0,0 +1,26 @@ +/** + * AUTO-GENERATED - DO NOT EDIT. Source: https://github.com/gpuweb/cts + **/ import { DefaultTestFileLoader } from '../../framework/file_loader.js'; +import { Logger } from '../../framework/logging/logger.js'; +import { parseQuery } from '../../framework/query/parseQuery.js'; +import { assert } from '../../framework/util/util.js'; + +// should be DedicatedWorkerGlobalScope + +const loader = new DefaultTestFileLoader(); + +self.onmessage = async ev => { + const query = ev.data.query; + const debug = ev.data.debug; + + const log = new Logger(debug); + + const testcases = Array.from(await loader.loadCases(parseQuery(query))); + assert(testcases.length === 1, 'worker query resulted in != 1 cases'); + + const testcase = testcases[0]; + const [rec, result] = log.record(testcase.query.toString()); + await testcase.run(rec); + + self.postMessage({ query, result }); +}; diff --git a/tests/wpt/webgpu/tests/webgpu/common/runtime/helper/test_worker.js b/tests/wpt/webgpu/tests/webgpu/common/runtime/helper/test_worker.js new file mode 100644 index 00000000000..f844920b50d --- /dev/null +++ b/tests/wpt/webgpu/tests/webgpu/common/runtime/helper/test_worker.js @@ -0,0 +1,51 @@ +/** + * AUTO-GENERATED - DO NOT EDIT. Source: https://github.com/gpuweb/cts + **/ function _defineProperty(obj, key, value) { + if (key in obj) { + Object.defineProperty(obj, key, { + value: value, + enumerable: true, + configurable: true, + writable: true, + }); + } else { + obj[key] = value; + } + return obj; +} +import { LogMessageWithStack } from '../../framework/logging/log_message.js'; + +export class TestWorker { + constructor(debug) { + _defineProperty(this, 'debug', void 0); + _defineProperty(this, 'worker', void 0); + _defineProperty(this, 'resolvers', new Map()); + this.debug = debug; + + const selfPath = import.meta.url; + const selfPathDir = selfPath.substring(0, selfPath.lastIndexOf('/')); + const workerPath = selfPathDir + '/test_worker-worker.js'; + this.worker = new Worker(workerPath, { type: 'module' }); + this.worker.onmessage = ev => { + const query = ev.data.query; + const result = ev.data.result; + if (result.logs) { + for (const l of result.logs) { + Object.setPrototypeOf(l, LogMessageWithStack.prototype); + } + } + this.resolvers.get(query)(result); + + // TODO(kainino0x): update the Logger with this result (or don't have a logger and update the + // entire results JSON somehow at some point). + }; + } + + async run(rec, query) { + this.worker.postMessage({ query, debug: this.debug }); + const workerResult = await new Promise(resolve => { + this.resolvers.set(query, resolve); + }); + rec.injectResult(workerResult); + } +} diff --git a/tests/wpt/webgpu/tests/webgpu/common/runtime/wpt.js b/tests/wpt/webgpu/tests/webgpu/common/runtime/wpt.js new file mode 100644 index 00000000000..5749159538d --- /dev/null +++ b/tests/wpt/webgpu/tests/webgpu/common/runtime/wpt.js @@ -0,0 +1,58 @@ +/** + * AUTO-GENERATED - DO NOT EDIT. Source: https://github.com/gpuweb/cts + **/ import { DefaultTestFileLoader } from '../framework/file_loader.js'; +import { Logger } from '../framework/logging/logger.js'; +import { parseQuery } from '../framework/query/parseQuery.js'; + +import { AsyncMutex } from '../framework/util/async_mutex.js'; +import { assert } from '../framework/util/util.js'; + +import { optionEnabled } from './helper/options.js'; +import { TestWorker } from './helper/test_worker.js'; + +(async () => { + const loader = new DefaultTestFileLoader(); + const qs = new URLSearchParams(window.location.search).getAll('q'); + assert(qs.length === 1, 'currently, there must be exactly one ?q='); + const testcases = await loader.loadCases(parseQuery(qs[0])); + + await addWPTTests(testcases); +})(); + +// Note: `async_test`s must ALL be added within the same task. This function *must not* be async. +function addWPTTests(testcases) { + const worker = optionEnabled('worker') ? new TestWorker(false) : undefined; + + const log = new Logger(false); + const mutex = new AsyncMutex(); + const running = []; + + for (const testcase of testcases) { + const name = testcase.query.toString(); + const wpt_fn = function () { + const p = mutex.with(async () => { + const [rec, res] = log.record(name); + if (worker) { + await worker.run(rec, name); + } else { + await testcase.run(rec); + } + + this.step(() => { + // Unfortunately, it seems not possible to surface any logs for warn/skip. + if (res.status === 'fail') { + throw (res.logs || []).map(s => s.toJSON()).join('\n\n'); + } + }); + this.done(); + }); + + running.push(p); + return p; + }; + + async_test(wpt_fn, name); + } + + return Promise.all(running).then(() => log); +} diff --git a/tests/wpt/webgpu/tests/webgpu/cts.html b/tests/wpt/webgpu/tests/webgpu/cts.html new file mode 100644 index 00000000000..ea93cd81ce1 --- /dev/null +++ b/tests/wpt/webgpu/tests/webgpu/cts.html @@ -0,0 +1,71 @@ + + + + +WebGPU CTS + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/tests/wpt/webgpu/tests/webgpu/webgpu/api/operation/buffers/create_mapped.spec.js b/tests/wpt/webgpu/tests/webgpu/webgpu/api/operation/buffers/create_mapped.spec.js new file mode 100644 index 00000000000..0f950439b9d --- /dev/null +++ b/tests/wpt/webgpu/tests/webgpu/webgpu/api/operation/buffers/create_mapped.spec.js @@ -0,0 +1,25 @@ +/** + * AUTO-GENERATED - DO NOT EDIT. Source: https://github.com/gpuweb/cts + **/ export const description = ''; +import { params, pbool, poptions } from '../../../../common/framework/params_builder.js'; +import { makeTestGroup } from '../../../../common/framework/test_group.js'; + +import { MappingTest } from './mapping_test.js'; + +export const g = makeTestGroup(MappingTest); + +g.test('createBufferMapped') + .params( + params() + .combine(poptions('size', [12, 512 * 1024])) + .combine(pbool('mappable')) + ) + .fn(t => { + const { size, mappable } = t.params; + const [buffer, arrayBuffer] = t.device.createBufferMapped({ + size, + usage: GPUBufferUsage.COPY_SRC | (mappable ? GPUBufferUsage.MAP_WRITE : 0), + }); + + t.checkMapWrite(buffer, arrayBuffer, size); + }); diff --git a/tests/wpt/webgpu/tests/webgpu/webgpu/api/operation/buffers/map.spec.js b/tests/wpt/webgpu/tests/webgpu/webgpu/api/operation/buffers/map.spec.js new file mode 100644 index 00000000000..19e1a2cc7c5 --- /dev/null +++ b/tests/wpt/webgpu/tests/webgpu/webgpu/api/operation/buffers/map.spec.js @@ -0,0 +1,59 @@ +/** + * AUTO-GENERATED - DO NOT EDIT. Source: https://github.com/gpuweb/cts + **/ export const description = ''; +import { pbool, poptions, params } from '../../../../common/framework/params_builder.js'; +import { makeTestGroup } from '../../../../common/framework/test_group.js'; + +import { MappingTest } from './mapping_test.js'; + +export const g = makeTestGroup(MappingTest); + +g.test('mapWriteAsync') + .params(poptions('size', [12, 512 * 1024])) + .fn(async t => { + const { size } = t.params; + const buffer = t.device.createBuffer({ + size, + usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE, + }); + + const arrayBuffer = await buffer.mapWriteAsync(); + t.checkMapWrite(buffer, arrayBuffer, size); + }); + +g.test('mapReadAsync') + .params(poptions('size', [12, 512 * 1024])) + .fn(async t => { + const { size } = t.params; + + const [buffer, init] = t.device.createBufferMapped({ + size, + usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ, + }); + + const expected = new Uint32Array(new ArrayBuffer(size)); + const data = new Uint32Array(init); + for (let i = 0; i < data.length; ++i) { + data[i] = expected[i] = i + 1; + } + buffer.unmap(); + + const actual = new Uint8Array(await buffer.mapReadAsync()); + t.expectBuffer(actual, new Uint8Array(expected.buffer)); + }); + +g.test('createBufferMapped') + .params( + params() + .combine(poptions('size', [12, 512 * 1024])) + .combine(pbool('mappable')) + ) + .fn(async t => { + const { size, mappable } = t.params; + const [buffer, arrayBuffer] = t.device.createBufferMapped({ + size, + usage: GPUBufferUsage.COPY_SRC | (mappable ? GPUBufferUsage.MAP_WRITE : 0), + }); + + t.checkMapWrite(buffer, arrayBuffer, size); + }); diff --git a/tests/wpt/webgpu/tests/webgpu/webgpu/api/operation/buffers/map_detach.spec.js b/tests/wpt/webgpu/tests/webgpu/webgpu/api/operation/buffers/map_detach.spec.js new file mode 100644 index 00000000000..61f2d7aa9fb --- /dev/null +++ b/tests/wpt/webgpu/tests/webgpu/webgpu/api/operation/buffers/map_detach.spec.js @@ -0,0 +1,69 @@ +/** + * AUTO-GENERATED - DO NOT EDIT. Source: https://github.com/gpuweb/cts + **/ export const description = ''; +import { makeTestGroup } from '../../../../common/framework/test_group.js'; +import { GPUTest } from '../../../gpu_test.js'; + +class F extends GPUTest { + checkDetach(buffer, arrayBuffer, unmap, destroy) { + const view = new Uint8Array(arrayBuffer); + this.expect(arrayBuffer.byteLength === 4); + this.expect(view.length === 4); + + if (unmap) buffer.unmap(); + if (destroy) buffer.destroy(); + + this.expect(arrayBuffer.byteLength === 0, 'ArrayBuffer should be detached'); + this.expect(view.byteLength === 0, 'ArrayBufferView should be detached'); + } +} + +export const g = makeTestGroup(F); + +g.test('mapWriteAsync') + .params([ + { unmap: true, destroy: false }, // + { unmap: false, destroy: true }, + { unmap: true, destroy: true }, + ]) + .fn(async t => { + const buffer = t.device.createBuffer({ size: 4, usage: GPUBufferUsage.MAP_WRITE }); + const arrayBuffer = await buffer.mapWriteAsync(); + t.checkDetach(buffer, arrayBuffer, t.params.unmap, t.params.destroy); + }); + +g.test('mapReadAsync') + .params([ + { unmap: true, destroy: false }, // + { unmap: false, destroy: true }, + { unmap: true, destroy: true }, + ]) + .fn(async t => { + const buffer = t.device.createBuffer({ size: 4, usage: GPUBufferUsage.MAP_READ }); + const arrayBuffer = await buffer.mapReadAsync(); + t.checkDetach(buffer, arrayBuffer, t.params.unmap, t.params.destroy); + }); + +g.test('create_mapped') + .params([ + { unmap: true, destroy: false }, + { unmap: false, destroy: true }, + { unmap: true, destroy: true }, + ]) + .fn(async t => { + const desc = { + size: 4, + usage: GPUBufferUsage.MAP_WRITE, + }; + + const [buffer, arrayBuffer] = t.device.createBufferMapped(desc); + + const view = new Uint8Array(arrayBuffer); + t.expect(arrayBuffer.byteLength === 4); + t.expect(view.length === 4); + + if (t.params.unmap) buffer.unmap(); + if (t.params.destroy) buffer.destroy(); + t.expect(arrayBuffer.byteLength === 0, 'ArrayBuffer should be detached'); + t.expect(view.byteLength === 0, 'ArrayBufferView should be detached'); + }); diff --git a/tests/wpt/webgpu/tests/webgpu/webgpu/api/operation/buffers/map_oom.spec.js b/tests/wpt/webgpu/tests/webgpu/webgpu/api/operation/buffers/map_oom.spec.js new file mode 100644 index 00000000000..f80fa767c08 --- /dev/null +++ b/tests/wpt/webgpu/tests/webgpu/webgpu/api/operation/buffers/map_oom.spec.js @@ -0,0 +1,34 @@ +/** + * AUTO-GENERATED - DO NOT EDIT. Source: https://github.com/gpuweb/cts + **/ export const description = ''; +import { makeTestGroup } from '../../../../common/framework/test_group.js'; +import { GPUTest } from '../../../gpu_test.js'; + +function getBufferDesc(usage) { + return { + size: Number.MAX_SAFE_INTEGER, + usage, + }; +} + +export const g = makeTestGroup(GPUTest); + +g.test('mapWriteAsync').fn(async t => { + const buffer = t.expectGPUError('out-of-memory', () => { + return t.device.createBuffer(getBufferDesc(GPUBufferUsage.MAP_WRITE)); + }); + t.shouldReject('OperationError', buffer.mapWriteAsync()); +}); + +g.test('mapReadAsync').fn(async t => { + const buffer = t.expectGPUError('out-of-memory', () => { + return t.device.createBuffer(getBufferDesc(GPUBufferUsage.MAP_READ)); + }); + t.shouldReject('OperationError', buffer.mapReadAsync()); +}); + +g.test('createBufferMapped').fn(async t => { + t.shouldThrow('RangeError', () => { + t.device.createBufferMapped(getBufferDesc(GPUBufferUsage.COPY_SRC)); + }); +}); diff --git a/tests/wpt/webgpu/tests/webgpu/webgpu/api/operation/buffers/mapping_test.js b/tests/wpt/webgpu/tests/webgpu/webgpu/api/operation/buffers/mapping_test.js new file mode 100644 index 00000000000..ad2be711d40 --- /dev/null +++ b/tests/wpt/webgpu/tests/webgpu/webgpu/api/operation/buffers/mapping_test.js @@ -0,0 +1,34 @@ +/** + * AUTO-GENERATED - DO NOT EDIT. Source: https://github.com/gpuweb/cts + **/ import { GPUTest } from '../../../gpu_test.js'; +export class MappingTest extends GPUTest { + checkMapWrite(buffer, mappedContents, size) { + this.checkMapWriteZeroed(mappedContents, size); + + const mappedView = new Uint32Array(mappedContents); + const expected = new Uint32Array(new ArrayBuffer(size)); + this.expect(mappedView.byteLength === size); + for (let i = 0; i < mappedView.length; ++i) { + mappedView[i] = expected[i] = i + 1; + } + buffer.unmap(); + + this.expectContents(buffer, expected); + } + + checkMapWriteZeroed(arrayBuffer, expectedSize) { + this.expect(arrayBuffer.byteLength === expectedSize); + const view = new Uint8Array(arrayBuffer); + this.expectZero(view); + } + + expectZero(actual) { + const size = actual.byteLength; + for (let i = 0; i < size; ++i) { + if (actual[i] !== 0) { + this.fail(`at [${i}], expected zero, got ${actual[i]}`); + break; + } + } + } +} diff --git a/tests/wpt/webgpu/tests/webgpu/webgpu/api/operation/command_buffer/basic.spec.js b/tests/wpt/webgpu/tests/webgpu/webgpu/api/operation/command_buffer/basic.spec.js new file mode 100644 index 00000000000..7f4dd29b24f --- /dev/null +++ b/tests/wpt/webgpu/tests/webgpu/webgpu/api/operation/command_buffer/basic.spec.js @@ -0,0 +1,15 @@ +/** + * AUTO-GENERATED - DO NOT EDIT. Source: https://github.com/gpuweb/cts + **/ export const description = ` +Basic tests. +`; +import { makeTestGroup } from '../../../../common/framework/test_group.js'; +import { GPUTest } from '../../../gpu_test.js'; + +export const g = makeTestGroup(GPUTest); + +g.test('empty').fn(async t => { + const encoder = t.device.createCommandEncoder(); + const cmd = encoder.finish(); + t.device.defaultQueue.submit([cmd]); +}); diff --git a/tests/wpt/webgpu/tests/webgpu/webgpu/api/operation/command_buffer/compute/basic.spec.js b/tests/wpt/webgpu/tests/webgpu/webgpu/api/operation/command_buffer/compute/basic.spec.js new file mode 100644 index 00000000000..865601f869b --- /dev/null +++ b/tests/wpt/webgpu/tests/webgpu/webgpu/api/operation/command_buffer/compute/basic.spec.js @@ -0,0 +1,74 @@ +/** + * AUTO-GENERATED - DO NOT EDIT. Source: https://github.com/gpuweb/cts + **/ export const description = ` +Basic command buffer compute tests. +`; +import { makeTestGroup } from '../../../../../common/framework/test_group.js'; +import { GPUTest } from '../../../../gpu_test.js'; + +export const g = makeTestGroup(GPUTest); + +g.test('memcpy').fn(async t => { + const data = new Uint32Array([0x01020304]); + + const [src, srcData] = t.device.createBufferMapped({ + size: 4, + usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.STORAGE, + }); + + new Uint32Array(srcData).set(data); + src.unmap(); + + const dst = t.device.createBuffer({ + size: 4, + usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE, + }); + + const bgl = t.device.createBindGroupLayout({ + entries: [ + { binding: 0, visibility: 4, type: 'storage-buffer' }, + { binding: 1, visibility: 4, type: 'storage-buffer' }, + ], + }); + + const bg = t.device.createBindGroup({ + entries: [ + { binding: 0, resource: { buffer: src, offset: 0, size: 4 } }, + { binding: 1, resource: { buffer: dst, offset: 0, size: 4 } }, + ], + + layout: bgl, + }); + + const module = t.makeShaderModule('compute', { + glsl: ` + #version 310 es + layout(std140, set = 0, binding = 0) buffer Src { + int value; + } src; + layout(std140, set = 0, binding = 1) buffer Dst { + int value; + } dst; + + void main() { + dst.value = src.value; + } + `, + }); + + const pl = t.device.createPipelineLayout({ bindGroupLayouts: [bgl] }); + const pipeline = t.device.createComputePipeline({ + computeStage: { module, entryPoint: 'main' }, + layout: pl, + }); + + const encoder = t.device.createCommandEncoder(); + const pass = encoder.beginComputePass(); + pass.setPipeline(pipeline); + pass.setBindGroup(0, bg); + pass.dispatch(1, 1, 1); + pass.endPass(); + t.device.defaultQueue.submit([encoder.finish()]); + + t.expectContents(dst, data); +}); diff --git a/tests/wpt/webgpu/tests/webgpu/webgpu/api/operation/command_buffer/copies.spec.js b/tests/wpt/webgpu/tests/webgpu/webgpu/api/operation/command_buffer/copies.spec.js new file mode 100644 index 00000000000..29d0bd58ee9 --- /dev/null +++ b/tests/wpt/webgpu/tests/webgpu/webgpu/api/operation/command_buffer/copies.spec.js @@ -0,0 +1,121 @@ +/** + * AUTO-GENERATED - DO NOT EDIT. Source: https://github.com/gpuweb/cts + **/ export const description = ` +copy{Buffer,Texture}To{Buffer,Texture} tests. +`; +import { makeTestGroup } from '../../../../common/framework/test_group.js'; +import { GPUTest } from '../../../gpu_test.js'; + +export const g = makeTestGroup(GPUTest); + +g.test('b2b').fn(async t => { + const data = new Uint32Array([0x01020304]); + + const [src, map] = t.device.createBufferMapped({ + size: 4, + usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST, + }); + + new Uint32Array(map).set(data); + src.unmap(); + + const dst = t.device.createBuffer({ + size: 4, + usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST, + }); + + const encoder = t.device.createCommandEncoder(); + encoder.copyBufferToBuffer(src, 0, dst, 0, 4); + t.device.defaultQueue.submit([encoder.finish()]); + + t.expectContents(dst, data); +}); + +g.test('b2t2b').fn(async t => { + const data = new Uint32Array([0x01020304]); + + const [src, map] = t.device.createBufferMapped({ + size: 4, + usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST, + }); + + new Uint32Array(map).set(data); + src.unmap(); + + const dst = t.device.createBuffer({ + size: 4, + usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST, + }); + + const mid = t.device.createTexture({ + size: { width: 1, height: 1, depth: 1 }, + format: 'rgba8uint', + usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.COPY_DST, + }); + + const encoder = t.device.createCommandEncoder(); + encoder.copyBufferToTexture( + { buffer: src, bytesPerRow: 256 }, + { texture: mid, mipLevel: 0, origin: { x: 0, y: 0, z: 0 } }, + { width: 1, height: 1, depth: 1 } + ); + + encoder.copyTextureToBuffer( + { texture: mid, mipLevel: 0, origin: { x: 0, y: 0, z: 0 } }, + { buffer: dst, bytesPerRow: 256 }, + { width: 1, height: 1, depth: 1 } + ); + + t.device.defaultQueue.submit([encoder.finish()]); + + t.expectContents(dst, data); +}); + +g.test('b2t2t2b').fn(async t => { + const data = new Uint32Array([0x01020304]); + + const [src, map] = t.device.createBufferMapped({ + size: 4, + usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST, + }); + + new Uint32Array(map).set(data); + src.unmap(); + + const dst = t.device.createBuffer({ + size: 4, + usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST, + }); + + const midDesc = { + size: { width: 1, height: 1, depth: 1 }, + format: 'rgba8uint', + usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.COPY_DST, + }; + + const mid1 = t.device.createTexture(midDesc); + const mid2 = t.device.createTexture(midDesc); + + const encoder = t.device.createCommandEncoder(); + encoder.copyBufferToTexture( + { buffer: src, bytesPerRow: 256 }, + { texture: mid1, mipLevel: 0, origin: { x: 0, y: 0, z: 0 } }, + { width: 1, height: 1, depth: 1 } + ); + + encoder.copyTextureToTexture( + { texture: mid1, mipLevel: 0, origin: { x: 0, y: 0, z: 0 } }, + { texture: mid2, mipLevel: 0, origin: { x: 0, y: 0, z: 0 } }, + { width: 1, height: 1, depth: 1 } + ); + + encoder.copyTextureToBuffer( + { texture: mid2, mipLevel: 0, origin: { x: 0, y: 0, z: 0 } }, + { buffer: dst, bytesPerRow: 256 }, + { width: 1, height: 1, depth: 1 } + ); + + t.device.defaultQueue.submit([encoder.finish()]); + + t.expectContents(dst, data); +}); diff --git a/tests/wpt/webgpu/tests/webgpu/webgpu/api/operation/command_buffer/render/basic.spec.js b/tests/wpt/webgpu/tests/webgpu/webgpu/api/operation/command_buffer/render/basic.spec.js new file mode 100644 index 00000000000..d3913ef5752 --- /dev/null +++ b/tests/wpt/webgpu/tests/webgpu/webgpu/api/operation/command_buffer/render/basic.spec.js @@ -0,0 +1,46 @@ +/** + * AUTO-GENERATED - DO NOT EDIT. Source: https://github.com/gpuweb/cts + **/ export const description = ` +Basic command buffer rendering tests. +`; +import { makeTestGroup } from '../../../../../common/framework/test_group.js'; +import { GPUTest } from '../../../../gpu_test.js'; + +export const g = makeTestGroup(GPUTest); + +g.test('clear').fn(async t => { + const dst = t.device.createBuffer({ + size: 4, + usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST, + }); + + const colorAttachment = t.device.createTexture({ + format: 'rgba8unorm', + size: { width: 1, height: 1, depth: 1 }, + usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.OUTPUT_ATTACHMENT, + }); + + const colorAttachmentView = colorAttachment.createView(); + + const encoder = t.device.createCommandEncoder(); + const pass = encoder.beginRenderPass({ + colorAttachments: [ + { + attachment: colorAttachmentView, + loadValue: { r: 0.0, g: 1.0, b: 0.0, a: 1.0 }, + storeOp: 'store', + }, + ], + }); + + pass.endPass(); + encoder.copyTextureToBuffer( + { texture: colorAttachment, mipLevel: 0, origin: { x: 0, y: 0, z: 0 } }, + { buffer: dst, bytesPerRow: 256 }, + { width: 1, height: 1, depth: 1 } + ); + + t.device.defaultQueue.submit([encoder.finish()]); + + t.expectContents(dst, new Uint8Array([0x00, 0xff, 0x00, 0xff])); +}); diff --git a/tests/wpt/webgpu/tests/webgpu/webgpu/api/operation/command_buffer/render/rendering.spec.js b/tests/wpt/webgpu/tests/webgpu/webgpu/api/operation/command_buffer/render/rendering.spec.js new file mode 100644 index 00000000000..60e843a6973 --- /dev/null +++ b/tests/wpt/webgpu/tests/webgpu/webgpu/api/operation/command_buffer/render/rendering.spec.js @@ -0,0 +1,85 @@ +/** + * AUTO-GENERATED - DO NOT EDIT. Source: https://github.com/gpuweb/cts + **/ export const description = ''; +import { makeTestGroup } from '../../../../../common/framework/test_group.js'; +import { GPUTest } from '../../../../gpu_test.js'; + +export const g = makeTestGroup(GPUTest); + +g.test('fullscreen_quad').fn(async t => { + const dst = t.device.createBuffer({ + size: 4, + usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST, + }); + + const colorAttachment = t.device.createTexture({ + format: 'rgba8unorm', + size: { width: 1, height: 1, depth: 1 }, + usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.OUTPUT_ATTACHMENT, + }); + + const colorAttachmentView = colorAttachment.createView(); + + const vertexModule = t.makeShaderModule('vertex', { + glsl: ` + #version 310 es + void main() { + const vec2 pos[3] = vec2[3]( + vec2(-1.f, -3.f), vec2(3.f, 1.f), vec2(-1.f, 1.f)); + gl_Position = vec4(pos[gl_VertexIndex], 0.f, 1.f); + } + `, + }); + + const fragmentModule = t.makeShaderModule('fragment', { + glsl: ` + #version 310 es + precision mediump float; + layout(location = 0) out vec4 fragColor; + void main() { + fragColor = vec4(0.0, 1.0, 0.0, 1.0); + } + `, + }); + + const pl = t.device.createPipelineLayout({ bindGroupLayouts: [] }); + const pipeline = t.device.createRenderPipeline({ + vertexStage: { module: vertexModule, entryPoint: 'main' }, + fragmentStage: { module: fragmentModule, entryPoint: 'main' }, + layout: pl, + primitiveTopology: 'triangle-list', + rasterizationState: { + frontFace: 'ccw', + }, + + colorStates: [{ format: 'rgba8unorm', alphaBlend: {}, colorBlend: {} }], + vertexState: { + indexFormat: 'uint16', + vertexBuffers: [], + }, + }); + + const encoder = t.device.createCommandEncoder(); + const pass = encoder.beginRenderPass({ + colorAttachments: [ + { + attachment: colorAttachmentView, + storeOp: 'store', + loadValue: { r: 1.0, g: 0.0, b: 0.0, a: 1.0 }, + }, + ], + }); + + pass.setPipeline(pipeline); + pass.draw(3, 1, 0, 0); + pass.endPass(); + encoder.copyTextureToBuffer( + { texture: colorAttachment, mipLevel: 0, origin: { x: 0, y: 0, z: 0 } }, + { buffer: dst, bytesPerRow: 256 }, + { width: 1, height: 1, depth: 1 } + ); + + t.device.defaultQueue.submit([encoder.finish()]); + + t.expectContents(dst, new Uint8Array([0x00, 0xff, 0x00, 0xff])); +}); diff --git a/tests/wpt/webgpu/tests/webgpu/webgpu/api/operation/command_buffer/render/storeop.spec.js b/tests/wpt/webgpu/tests/webgpu/webgpu/api/operation/command_buffer/render/storeop.spec.js new file mode 100644 index 00000000000..cd0c9d6145e --- /dev/null +++ b/tests/wpt/webgpu/tests/webgpu/webgpu/api/operation/command_buffer/render/storeop.spec.js @@ -0,0 +1,78 @@ +/** + * AUTO-GENERATED - DO NOT EDIT. Source: https://github.com/gpuweb/cts + **/ export const description = ` +renderPass store op test that drawn quad is either stored or cleared based on storeop`; +import { makeTestGroup } from '../../../../../common/framework/test_group.js'; +import { GPUTest } from '../../../../gpu_test.js'; + +export const g = makeTestGroup(GPUTest); + +g.test('storeOp_controls_whether_1x1_drawn_quad_is_stored') + .params([ + { storeOp: 'store', _expected: 1 }, // + { storeOp: 'clear', _expected: 0 }, + ]) + .fn(async t => { + const renderTexture = t.device.createTexture({ + size: { width: 1, height: 1, depth: 1 }, + format: 'r8unorm', + usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.OUTPUT_ATTACHMENT, + }); + + // create render pipeline + const vertexModule = t.makeShaderModule('vertex', { + glsl: ` + #version 450 + const vec2 pos[3] = vec2[3]( + vec2( 1.0f, -1.0f), + vec2( 1.0f, 1.0f), + vec2(-1.0f, 1.0f) + ); + + void main() { + gl_Position = vec4(pos[gl_VertexIndex], 0.0, 1.0); + } + `, + }); + + const fragmentModule = t.makeShaderModule('fragment', { + glsl: ` + #version 450 + layout(location = 0) out vec4 fragColor; + void main() { + fragColor = vec4(1.0, 0.0, 0.0, 1.0); + } + `, + }); + + const renderPipeline = t.device.createRenderPipeline({ + vertexStage: { module: vertexModule, entryPoint: 'main' }, + fragmentStage: { module: fragmentModule, entryPoint: 'main' }, + layout: t.device.createPipelineLayout({ bindGroupLayouts: [] }), + primitiveTopology: 'triangle-list', + colorStates: [{ format: 'r8unorm' }], + }); + + // encode pass and submit + const encoder = t.device.createCommandEncoder(); + const pass = encoder.beginRenderPass({ + colorAttachments: [ + { + attachment: renderTexture.createView(), + storeOp: t.params.storeOp, + loadValue: { r: 0.0, g: 0.0, b: 0.0, a: 0.0 }, + }, + ], + }); + + pass.setPipeline(renderPipeline); + pass.draw(3, 1, 0, 0); + pass.endPass(); + t.device.defaultQueue.submit([encoder.finish()]); + + // expect the buffer to be clear + t.expectSingleColor(renderTexture, 'r8unorm', { + size: [1, 1, 1], + exp: { R: t.params._expected }, + }); + }); diff --git a/tests/wpt/webgpu/tests/webgpu/webgpu/api/operation/fences.spec.js b/tests/wpt/webgpu/tests/webgpu/webgpu/api/operation/fences.spec.js new file mode 100644 index 00000000000..98f913008b8 --- /dev/null +++ b/tests/wpt/webgpu/tests/webgpu/webgpu/api/operation/fences.spec.js @@ -0,0 +1,145 @@ +/** + * AUTO-GENERATED - DO NOT EDIT. Source: https://github.com/gpuweb/cts + **/ export const description = ''; +import { makeTestGroup } from '../../../common/framework/test_group.js'; +import { attemptGarbageCollection } from '../../../common/framework/util/collect_garbage.js'; +import { raceWithRejectOnTimeout } from '../../../common/framework/util/util.js'; +import { GPUTest } from '../../gpu_test.js'; + +export const g = makeTestGroup(GPUTest); + +g.test('initial,no_descriptor').fn(t => { + const fence = t.queue.createFence(); + t.expect(fence.getCompletedValue() === 0); +}); + +g.test('initial,empty_descriptor').fn(t => { + const fence = t.queue.createFence({}); + t.expect(fence.getCompletedValue() === 0); +}); + +g.test('initial,descriptor_with_initialValue').fn(t => { + const fence = t.queue.createFence({ initialValue: 2 }); + t.expect(fence.getCompletedValue() === 2); +}); + +// Promise resolves when onCompletion value is less than signal value. +g.test('wait,less_than_signaled').fn(async t => { + const fence = t.queue.createFence(); + t.queue.signal(fence, 2); + await fence.onCompletion(1); + t.expect(fence.getCompletedValue() === 2); +}); + +// Promise resolves when onCompletion value is equal to signal value. +g.test('wait,equal_to_signaled').fn(async t => { + const fence = t.queue.createFence(); + t.queue.signal(fence, 2); + await fence.onCompletion(2); + t.expect(fence.getCompletedValue() === 2); +}); + +// All promises resolve when signal is called once. +g.test('wait,signaled_once').fn(async t => { + const fence = t.queue.createFence(); + t.queue.signal(fence, 20); + const promises = []; + for (let i = 0; i <= 20; ++i) { + promises.push( + fence.onCompletion(i).then(() => { + t.expect(fence.getCompletedValue() >= i); + }) + ); + } + await Promise.all(promises); +}); + +// Promise resolves when signal is called multiple times. +g.test('wait,signaled_multiple_times').fn(async t => { + const fence = t.queue.createFence(); + t.queue.signal(fence, 1); + t.queue.signal(fence, 2); + await fence.onCompletion(2); + t.expect(fence.getCompletedValue() === 2); +}); + +// Promise resolves if fence has already completed. +g.test('wait,already_completed').fn(async t => { + const fence = t.queue.createFence(); + t.queue.signal(fence, 2); + + // Wait for value to update. + while (fence.getCompletedValue() < 2) { + await new Promise(resolve => { + requestAnimationFrame(resolve); + }); + } + + t.expect(fence.getCompletedValue() === 2); + + await fence.onCompletion(2); + t.expect(fence.getCompletedValue() === 2); +}); + +// Test many calls to signal and wait on fence values one at a time. +g.test('wait,many,serially').fn(async t => { + const fence = t.queue.createFence(); + for (let i = 1; i <= 20; ++i) { + t.queue.signal(fence, i); + await fence.onCompletion(i); + t.expect(fence.getCompletedValue() === i); + } +}); + +// Test many calls to signal and wait on all fence values. +g.test('wait,many,parallel').fn(async t => { + const fence = t.queue.createFence(); + const promises = []; + for (let i = 1; i <= 20; ++i) { + t.queue.signal(fence, i); + promises.push( + fence.onCompletion(i).then(() => { + t.expect(fence.getCompletedValue() >= i); + }) + ); + } + await Promise.all(promises); + t.expect(fence.getCompletedValue() === 20); +}); + +// Test onCompletion promise resolves within a time limit. +g.test('wait,resolves_within_timeout').fn(t => { + const fence = t.queue.createFence(); + t.queue.signal(fence, 2); + + return raceWithRejectOnTimeout( + (async () => { + await fence.onCompletion(2); + t.expect(fence.getCompletedValue() === 2); + })(), + 100, + 'The fence has not been resolved within time limit.' + ); +}); + +// Test dropping references to the fence and onCompletion promise does not crash. +g.test('drop,fence_and_promise').fn(async t => { + { + const fence = t.queue.createFence(); + t.queue.signal(fence, 2); + fence.onCompletion(2); + } + await attemptGarbageCollection(); +}); + +// Test dropping references to the fence and holding the promise does not crash. +g.test('drop,promise').fn(async t => { + let promise; + { + const fence = t.queue.createFence(); + t.queue.signal(fence, 2); + promise = fence.onCompletion(2); + } + await attemptGarbageCollection(); + await promise; +}); diff --git a/tests/wpt/webgpu/tests/webgpu/webgpu/api/operation/render_pass/storeOp.spec.js b/tests/wpt/webgpu/tests/webgpu/webgpu/api/operation/render_pass/storeOp.spec.js new file mode 100644 index 00000000000..678a4629250 --- /dev/null +++ b/tests/wpt/webgpu/tests/webgpu/webgpu/api/operation/render_pass/storeOp.spec.js @@ -0,0 +1,24 @@ +/** + * AUTO-GENERATED - DO NOT EDIT. Source: https://github.com/gpuweb/cts + **/ export const description = `API Operation Tests for RenderPass StoreOp. + + Test Coverage Needed: + + - Test that a render pass has correct output for combinations of: + - All color attachments from '0' to 'MAX_COLOR_ATTACHMENTS' with combinations of: + - storeOp set to {'clear', 'store', 'undefined} + - All color renderable formats + - mip level set to {'0', mip > '0'} + - array layer set to {'0', layer > '1'} for 2D textures + - depth slice set to {'0', slice > '0'} for 3D textures + - With and without a depthStencilAttachment that has the combinations of: + - depthStoreOp set to {'clear', 'store', 'undefined'} + - stencilStoreOp set to {'clear', 'store', 'undefined'} + - All depth/stencil formats + - mip level set to {'0', mip > '0'} + - array layer set to {'0', layer > '1'} for 2D textures + - depth slice set to {'0', slice > '0'} for 3D textures`; +import { makeTestGroup } from '../../../../common/framework/test_group.js'; +import { GPUTest } from '../../../gpu_test.js'; + +export const g = makeTestGroup(GPUTest); diff --git a/tests/wpt/webgpu/tests/webgpu/webgpu/api/operation/render_pipeline/culling_tests.spec.js b/tests/wpt/webgpu/tests/webgpu/webgpu/api/operation/render_pipeline/culling_tests.spec.js new file mode 100644 index 00000000000..a10a987520d --- /dev/null +++ b/tests/wpt/webgpu/tests/webgpu/webgpu/api/operation/render_pipeline/culling_tests.spec.js @@ -0,0 +1,165 @@ +/** + * AUTO-GENERATED - DO NOT EDIT. Source: https://github.com/gpuweb/cts + **/ export const description = `Test culling and rasterizaion state. + +Test coverage: +Test all culling combinations of GPUFrontFace and GPUCullMode show the correct output. + +Use 2 triangles with different winding orders: + +- Test that the counter-clock wise triangle has correct output for: + - All FrontFaces (ccw, cw) + - All CullModes (none, front, back) + - All depth stencil attachment types (none, depth24plus, depth32float, depth24plus-stencil8) + - Some primitive topologies (triangle-list, TODO: triangle-strip) + +- Test that the clock wise triangle has correct output for: + - All FrontFaces (ccw, cw) + - All CullModes (none, front, back) + - All depth stencil attachment types (none, depth24plus, depth32float, depth24plus-stencil8) + - Some primitive topologies (triangle-list, TODO: triangle-strip) +`; +import { poptions, params } from '../../../../common/framework/params_builder.js'; +import { makeTestGroup } from '../../../../common/framework/test_group.js'; +import { GPUTest } from '../../../gpu_test.js'; + +function faceIsCulled(face, frontFace, cullMode) { + return cullMode !== 'none' && (frontFace === face) === (cullMode === 'front'); +} + +function faceColor(face, frontFace, cullMode) { + // front facing color is green, non front facing is red, background is blue + const isCulled = faceIsCulled(face, frontFace, cullMode); + if (!isCulled && face === frontFace) { + return new Uint8Array([0x00, 0xff, 0x00, 0xff]); + } else if (isCulled) { + return new Uint8Array([0x00, 0x00, 0xff, 0xff]); + } else { + return new Uint8Array([0xff, 0x00, 0x00, 0xff]); + } +} + +export const g = makeTestGroup(GPUTest); + +g.test('culling') + .params( + params() + .combine(poptions('frontFace', ['ccw', 'cw'])) + .combine(poptions('cullMode', ['none', 'front', 'back'])) + .combine( + poptions('depthStencilFormat', [ + null, + 'depth24plus', + 'depth32float', + 'depth24plus-stencil8', + ]) + ) + + // TODO: test triangle-strip as well + .combine(poptions('primitiveTopology', ['triangle-list'])) + ) + .fn(t => { + const size = 4; + const format = 'rgba8unorm'; + + const texture = t.device.createTexture({ + size: { width: size, height: size, depth: 1 }, + format, + usage: GPUTextureUsage.OUTPUT_ATTACHMENT | GPUTextureUsage.COPY_SRC, + }); + + const depthTexture = t.params.depthStencilFormat + ? t.device.createTexture({ + size: { width: size, height: size, depth: 1 }, + format: t.params.depthStencilFormat, + usage: GPUTextureUsage.OUTPUT_ATTACHMENT, + }) + : null; + + const encoder = t.device.createCommandEncoder(); + const pass = encoder.beginRenderPass({ + colorAttachments: [ + { + attachment: texture.createView(), + loadValue: { r: 0.0, g: 0.0, b: 1.0, a: 1.0 }, + }, + ], + + depthStencilAttachment: depthTexture + ? { + attachment: depthTexture.createView(), + depthLoadValue: 1.0, + depthStoreOp: 'store', + stencilLoadValue: 0, + stencilStoreOp: 'store', + } + : undefined, + }); + + // Draw two triangles with different winding orders: + // 1. The top-left one is counterclockwise (CCW) + // 2. The bottom-right one is clockwise (CW) + const vertexModule = t.makeShaderModule('vertex', { + glsl: `#version 450 + const vec2 pos[6] = vec2[6](vec2(-1.0f, 1.0f), + vec2(-1.0f, 0.0f), + vec2( 0.0f, 1.0f), + vec2( 0.0f, -1.0f), + vec2( 1.0f, 0.0f), + vec2( 1.0f, -1.0f)); + void main() { + gl_Position = vec4(pos[gl_VertexIndex], 0.0, 1.0); + }`, + }); + + const fragmentModule = t.makeShaderModule('fragment', { + glsl: `#version 450 + layout(location = 0) out vec4 fragColor; + void main() { + if (gl_FrontFacing) { + fragColor = vec4(0.0, 1.0, 0.0, 1.0); + } else { + fragColor = vec4(1.0, 0.0, 0.0, 1.0); + } + }`, + }); + + pass.setPipeline( + t.device.createRenderPipeline({ + vertexStage: { module: vertexModule, entryPoint: 'main' }, + fragmentStage: { module: fragmentModule, entryPoint: 'main' }, + primitiveTopology: t.params.primitiveTopology, + rasterizationState: { + frontFace: t.params.frontFace, + cullMode: t.params.cullMode, + }, + + colorStates: [{ format }], + depthStencilState: depthTexture ? { format: t.params.depthStencilFormat } : undefined, + }) + ); + + pass.draw(6, 1, 0, 0); + pass.endPass(); + + t.device.defaultQueue.submit([encoder.finish()]); + + // front facing color is green, non front facing is red, background is blue + const kCCWTriangleTopLeftColor = faceColor('ccw', t.params.frontFace, t.params.cullMode); + t.expectSinglePixelIn2DTexture( + texture, + format, + { x: 0, y: 0 }, + { exp: kCCWTriangleTopLeftColor } + ); + + const kCWTriangleBottomRightColor = faceColor('cw', t.params.frontFace, t.params.cullMode); + t.expectSinglePixelIn2DTexture( + texture, + format, + { x: size - 1, y: size - 1 }, + { exp: kCWTriangleBottomRightColor } + ); + + // TODO: check the contents of the depth and stencil outputs + }); diff --git a/tests/wpt/webgpu/tests/webgpu/webgpu/api/operation/resource_init/copied_texture_clear.spec.js b/tests/wpt/webgpu/tests/webgpu/webgpu/api/operation/resource_init/copied_texture_clear.spec.js new file mode 100644 index 00000000000..28fb5b368e3 --- /dev/null +++ b/tests/wpt/webgpu/tests/webgpu/webgpu/api/operation/resource_init/copied_texture_clear.spec.js @@ -0,0 +1,75 @@ +/** + * AUTO-GENERATED - DO NOT EDIT. Source: https://github.com/gpuweb/cts + **/ export const description = 'Test uninitialized textures are initialized to zero when copied.'; +import { makeTestGroup } from '../../../../common/framework/test_group.js'; +import { assert, unreachable } from '../../../../common/framework/util/util.js'; + +import { ReadMethod, TextureZeroInitTest } from './texture_zero_init_test.js'; + +class CopiedTextureClearTest extends TextureZeroInitTest { + checkContentsByBufferCopy(texture, state, subresourceRange) { + for (const { level: mipLevel, slice } of subresourceRange.each()) { + assert(this.params.dimension === '2d'); + + this.expectSingleColor(texture, this.params.format, { + size: [this.textureWidth, this.textureHeight, 1], + dimension: this.params.dimension, + slice, + layout: { mipLevel }, + exp: this.stateToTexelComponents[state], + }); + } + } + + checkContentsByTextureCopy(texture, state, subresourceRange) { + for (const { level, slice } of subresourceRange.each()) { + assert(this.params.dimension === '2d'); + + const width = this.textureWidth >> level; + const height = this.textureHeight >> level; + + const dst = this.device.createTexture({ + size: [width, height, 1], + format: this.params.format, + usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, + }); + + const commandEncoder = this.device.createCommandEncoder(); + commandEncoder.copyTextureToTexture( + { texture, mipLevel: level, origin: { x: 0, y: 0, z: slice } }, + { texture: dst, mipLevel: 0 }, + { width, height, depth: 1 } + ); + + this.queue.submit([commandEncoder.finish()]); + + this.expectSingleColor(dst, this.params.format, { + size: [width, height, 1], + exp: this.stateToTexelComponents[state], + }); + } + } + + checkContents(texture, state, subresourceRange) { + switch (this.params.readMethod) { + case ReadMethod.CopyToBuffer: + this.checkContentsByBufferCopy(texture, state, subresourceRange); + break; + + case ReadMethod.CopyToTexture: + this.checkContentsByTextureCopy(texture, state, subresourceRange); + break; + + default: + unreachable(); + } + } +} + +export const g = makeTestGroup(CopiedTextureClearTest); + +g.test('uninitialized_texture_is_zero') + .params(TextureZeroInitTest.generateParams([ReadMethod.CopyToBuffer, ReadMethod.CopyToTexture])) + .fn(t => { + t.run(); + }); diff --git a/tests/wpt/webgpu/tests/webgpu/webgpu/api/operation/resource_init/depth_stencil_attachment_clear.spec.js b/tests/wpt/webgpu/tests/webgpu/webgpu/api/operation/resource_init/depth_stencil_attachment_clear.spec.js new file mode 100644 index 00000000000..06004eadf34 --- /dev/null +++ b/tests/wpt/webgpu/tests/webgpu/webgpu/api/operation/resource_init/depth_stencil_attachment_clear.spec.js @@ -0,0 +1,213 @@ +/** + * AUTO-GENERATED - DO NOT EDIT. Source: https://github.com/gpuweb/cts + **/ export const description = + 'Test uninitialized textures are initialized to zero when used as a depth/stencil attachment.'; +import { makeTestGroup } from '../../../../common/framework/test_group.js'; +import { unreachable } from '../../../../common/framework/util/util.js'; + +import { + ReadMethod, + TextureZeroInitTest, + initializedStateAsDepth, + initializedStateAsStencil, +} from './texture_zero_init_test.js'; + +class DepthStencilAttachmentClearTest extends TextureZeroInitTest { + // Construct a pipeline which will render a single triangle with depth + // equal to |initializeStateAsDepth(state)|. The depth compare function + // is set to "equal" so the fragment shader will only write 1.0 to the + // R8Unorm output if the depth buffer contains exactly the expected value. + getDepthTestReadbackPipeline(state, format, sampleCount) { + return this.device.createRenderPipeline({ + vertexStage: { + entryPoint: 'main', + module: this.makeShaderModule('vertex', { + glsl: `#version 310 es + void main() { + const vec2 pos[3] = vec2[3]( + vec2(-1.f, -3.f), vec2(3.f, 1.f), vec2(-1.f, 1.f)); + gl_Position = vec4(pos[gl_VertexIndex], 0.f, 1.f); + } + `, + }), + }, + + fragmentStage: { + entryPoint: 'main', + module: this.makeShaderModule('fragment', { + glsl: `#version 310 es + precision highp float; + layout(location = 0) out float outSuccess; + + void main() { + gl_FragDepth = float(${initializedStateAsDepth(state)}); + outSuccess = 1.0; + } + `, + }), + }, + + colorStates: [ + { + format: 'r8unorm', + }, + ], + + depthStencilState: { + format, + depthCompare: 'equal', + }, + + primitiveTopology: 'triangle-list', + sampleCount, + }); + } + + // Construct a pipeline which will render a single triangle. + // The stencil compare function is set to "equal" so the fragment shader + // will only write 1.0 to the R8Unorm output if the stencil buffer contains + // exactly the stencil reference value. + getStencilTestReadbackPipeline(format, sampleCount) { + return this.device.createRenderPipeline({ + vertexStage: { + entryPoint: 'main', + module: this.makeShaderModule('vertex', { + glsl: `#version 310 es + void main() { + const vec2 pos[3] = vec2[3]( + vec2(-1.f, -3.f), vec2(3.f, 1.f), vec2(-1.f, 1.f)); + gl_Position = vec4(pos[gl_VertexIndex], 0.f, 1.f); + } + `, + }), + }, + + fragmentStage: { + entryPoint: 'main', + module: this.makeShaderModule('fragment', { + glsl: `#version 310 es + precision highp float; + layout(location = 0) out float outSuccess; + + void main() { + outSuccess = 1.0; + } + `, + }), + }, + + colorStates: [ + { + format: 'r8unorm', + }, + ], + + depthStencilState: { + format, + stencilFront: { + compare: 'equal', + }, + + stencilBack: { + compare: 'equal', + }, + }, + + primitiveTopology: 'triangle-list', + sampleCount, + }); + } + + // Check the contents by running either a depth or stencil test. The test will + // render 1.0 to an R8Unorm texture if the depth/stencil buffer is equal to the expected + // value. This is done by using a depth compare function and explicitly setting the depth + // value with gl_FragDepth in the shader, or by using a stencil compare function and + // setting the stencil reference value in the render pass. + checkContents(texture, state, subresourceRange) { + for (const viewDescriptor of this.generateTextureViewDescriptorsForRendering( + this.params.aspect, + subresourceRange + )) { + const width = this.textureWidth >> viewDescriptor.baseMipLevel; + const height = this.textureHeight >> viewDescriptor.baseMipLevel; + + const renderTexture = this.device.createTexture({ + size: [width, height, 1], + format: 'r8unorm', + usage: GPUTextureUsage.OUTPUT_ATTACHMENT | GPUTextureUsage.COPY_SRC, + sampleCount: this.params.sampleCount, + }); + + let resolveTexture = undefined; + let resolveTarget = undefined; + if (this.params.sampleCount > 1) { + resolveTexture = this.device.createTexture({ + size: [width, height, 1], + format: 'r8unorm', + usage: GPUTextureUsage.OUTPUT_ATTACHMENT | GPUTextureUsage.COPY_SRC, + }); + + resolveTarget = resolveTexture.createView(); + } + + const commandEncoder = this.device.createCommandEncoder(); + const pass = commandEncoder.beginRenderPass({ + colorAttachments: [ + { + attachment: renderTexture.createView(), + resolveTarget, + loadValue: [0, 0, 0, 0], + storeOp: 'store', + }, + ], + + depthStencilAttachment: { + attachment: texture.createView(viewDescriptor), + depthStoreOp: 'store', + depthLoadValue: 'load', + stencilStoreOp: 'store', + stencilLoadValue: 'load', + }, + }); + + switch (this.params.readMethod) { + case ReadMethod.DepthTest: + pass.setPipeline( + this.getDepthTestReadbackPipeline(state, this.params.format, this.params.sampleCount) + ); + + break; + + case ReadMethod.StencilTest: + pass.setPipeline( + this.getStencilTestReadbackPipeline(this.params.format, this.params.sampleCount) + ); + + // Set the stencil reference. The rendering pipeline uses stencil compare function "equal" + // so this pass will write 1.0 to the output only if the stencil buffer is equal to this + // reference value. + pass.setStencilReference(initializedStateAsStencil(state)); + break; + + default: + unreachable(); + } + + pass.draw(3, 1, 0, 0); + pass.endPass(); + + this.queue.submit([commandEncoder.finish()]); + + this.expectSingleColor(resolveTexture || renderTexture, 'r8unorm', { + size: [width, height, 1], + exp: { R: 1 }, + }); + } + } +} + +export const g = makeTestGroup(DepthStencilAttachmentClearTest); + +g.test('uninitialized_texture_is_zero') + .params(TextureZeroInitTest.generateParams([ReadMethod.DepthTest, ReadMethod.StencilTest])) + .fn(t => t.run()); diff --git a/tests/wpt/webgpu/tests/webgpu/webgpu/api/operation/resource_init/sampled_texture_clear.spec.js b/tests/wpt/webgpu/tests/webgpu/webgpu/api/operation/resource_init/sampled_texture_clear.spec.js new file mode 100644 index 00000000000..5ee102a37ff --- /dev/null +++ b/tests/wpt/webgpu/tests/webgpu/webgpu/api/operation/resource_init/sampled_texture_clear.spec.js @@ -0,0 +1,199 @@ +/** + * AUTO-GENERATED - DO NOT EDIT. Source: https://github.com/gpuweb/cts + **/ export const description = 'Test uninitialized textures are initialized to zero when sampled.'; +import { makeTestGroup } from '../../../../common/framework/test_group.js'; +import { assert } from '../../../../common/framework/util/util.js'; + +import { getTexelDataRepresentation } from '../../../util/texture/texelData.js'; + +import { + ReadMethod, + TextureZeroInitTest, + initializedStateAsFloat, + initializedStateAsSint, + initializedStateAsUint, +} from './texture_zero_init_test.js'; + +class SampledTextureClearTest extends TextureZeroInitTest { + getSamplingReadbackPipeline(prefix, sampleCount, dimension) { + const componentOrder = getTexelDataRepresentation(this.params.format).componentOrder; + const MS = sampleCount > 1 ? 'MS' : ''; + const XD = dimension.toUpperCase(); + const componentCount = componentOrder.length; + const indexExpression = + componentCount === 1 + ? componentOrder[0].toLowerCase() + : componentOrder.map(c => c.toLowerCase()).join('') + '[i]'; + + const glsl = `#version 310 es + precision highp float; + precision highp ${prefix}texture${XD}${MS}; + precision highp sampler; + + layout(set = 0, binding = 0, std140) uniform Constants { + int level; + }; + + layout(set = 0, binding = 1) uniform ${prefix}texture${XD}${MS} myTexture; + layout(set = 0, binding = 2) uniform sampler mySampler; + layout(set = 0, binding = 3, std430) writeonly buffer Result { + uint result[]; + }; + + void writeResult(uint flatIndex, uvec4 texel) { + for (uint i = flatIndex; i < flatIndex + ${componentCount}u; ++i) { + result[i] = texel.${indexExpression}; + } + } + + void writeResult(uint flatIndex, ivec4 texel) { + for (uint i = flatIndex; i < flatIndex + ${componentCount}u; ++i) { + result[i] = uint(texel.${indexExpression}); + } + } + + void writeResult(uint flatIndex, vec4 texel) { + for (uint i = flatIndex; i < flatIndex + ${componentCount}u; ++i) { + result[i] = floatBitsToUint(texel.${indexExpression}); + } + } + + void main() { + uint flatIndex = gl_NumWorkGroups.x * gl_GlobalInvocationID.y + gl_GlobalInvocationID.x; + flatIndex = flatIndex * ${componentCount}u; + + writeResult(flatIndex, texelFetch( + ${prefix}sampler${XD}${MS}(myTexture, mySampler), + ivec2(gl_GlobalInvocationID.xy), level)); + } + `; + + return this.device.createComputePipeline({ + layout: undefined, + computeStage: { + entryPoint: 'main', + module: this.makeShaderModule('compute', { glsl }), + }, + }); + } + + checkContents(texture, state, subresourceRange) { + assert(this.params.dimension === '2d'); + + const sampler = this.device.createSampler(); + + for (const { level, slices } of subresourceRange.mipLevels()) { + const width = this.textureWidth >> level; + const height = this.textureHeight >> level; + + let readbackTypedArray = Float32Array; + let prefix = ''; + let expectedShaderValue = initializedStateAsFloat(state); + if (this.params.format.indexOf('sint') !== -1) { + prefix = 'i'; + expectedShaderValue = initializedStateAsSint(state); + readbackTypedArray = Int32Array; + } else if (this.params.format.indexOf('uint') !== -1) { + prefix = 'u'; + expectedShaderValue = initializedStateAsUint(state); + readbackTypedArray = Uint32Array; + } + + const computePipeline = this.getSamplingReadbackPipeline( + prefix, + this.params.sampleCount, + this.params.dimension + ); + + for (const slice of slices) { + const [ubo, uboMapping] = this.device.createBufferMapped({ + size: 4, + usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST, + }); + + new Int32Array(uboMapping, 0, 1)[0] = level; + ubo.unmap(); + + const byteLength = + width * + height * + Uint32Array.BYTES_PER_ELEMENT * + getTexelDataRepresentation(this.params.format).componentOrder.length; + const resultBuffer = this.device.createBuffer({ + size: byteLength, + usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC, + }); + + const bindGroup = this.device.createBindGroup({ + layout: computePipeline.getBindGroupLayout(0), + entries: [ + { + binding: 0, + resource: { buffer: ubo }, + }, + + { + binding: 1, + resource: texture.createView({ + baseMipLevel: 0, + mipLevelCount: this.params.mipLevelCount, + baseArrayLayer: slice, + arrayLayerCount: 1, + }), + }, + + { binding: 2, resource: sampler }, + { + binding: 3, + resource: { + buffer: resultBuffer, + }, + }, + ], + }); + + const commandEncoder = this.device.createCommandEncoder(); + const pass = commandEncoder.beginComputePass(); + pass.setPipeline(computePipeline); + pass.setBindGroup(0, bindGroup); + pass.dispatch(width, height); + pass.endPass(); + this.queue.submit([commandEncoder.finish()]); + ubo.destroy(); + + const mappedResultBuffer = this.createCopyForMapRead(resultBuffer, 0, byteLength); + resultBuffer.destroy(); + + this.eventualAsyncExpectation(async niceStack => { + const actual = await mappedResultBuffer.mapReadAsync(); + const expected = new readbackTypedArray(new ArrayBuffer(actual.byteLength)); + expected.fill(expectedShaderValue); + + // TODO: Have a better way to determine approximately equal, maybe in ULPs. + let tolerance; + if (this.params.format === 'rgb10a2unorm') { + tolerance = i => { + // The alpha component is only two bits. Use a generous tolerance. + return i % 4 === 3 ? 0.18 : 0.01; + }; + } else { + tolerance = 0.01; + } + + const check = this.checkBuffer(new readbackTypedArray(actual), expected, tolerance); + if (check !== undefined) { + niceStack.message = check; + this.rec.expectationFailed(niceStack); + } + mappedResultBuffer.destroy(); + }); + } + } + } +} + +export const g = makeTestGroup(SampledTextureClearTest); + +g.test('uninitialized_texture_is_zero') + .params(TextureZeroInitTest.generateParams([ReadMethod.Sample])) + .fn(t => t.run()); diff --git a/tests/wpt/webgpu/tests/webgpu/webgpu/api/operation/resource_init/texture_zero_init_test.js b/tests/wpt/webgpu/tests/webgpu/webgpu/api/operation/resource_init/texture_zero_init_test.js new file mode 100644 index 00000000000..e3c21011bb2 --- /dev/null +++ b/tests/wpt/webgpu/tests/webgpu/webgpu/api/operation/resource_init/texture_zero_init_test.js @@ -0,0 +1,552 @@ +/** + * AUTO-GENERATED - DO NOT EDIT. Source: https://github.com/gpuweb/cts + **/ function _defineProperty(obj, key, value) { + if (key in obj) { + Object.defineProperty(obj, key, { + value: value, + enumerable: true, + configurable: true, + writable: true, + }); + } else { + obj[key] = value; + } + return obj; +} +import { params, poptions, pbool } from '../../../../common/framework/params_builder.js'; +import { assert, unreachable } from '../../../../common/framework/util/util.js'; +import { kTextureAspects, kTextureFormatInfo, kTextureFormats } from '../../../capability_info.js'; +import { GPUTest } from '../../../gpu_test.js'; +import { createTextureUploadBuffer } from '../../../util/texture/layout.js'; +import { SubresourceRange } from '../../../util/texture/subresource.js'; +import { getTexelDataRepresentation } from '../../../util/texture/texelData.js'; +var UninitializeMethod; +(function (UninitializeMethod) { + UninitializeMethod['Creation'] = 'Creation'; + UninitializeMethod['StoreOpClear'] = 'StoreOpClear'; +})(UninitializeMethod || (UninitializeMethod = {})); + +const kUninitializeMethods = Object.keys(UninitializeMethod); + +export let ReadMethod; +(function (ReadMethod) { + ReadMethod['Sample'] = 'Sample'; + ReadMethod['CopyToBuffer'] = 'CopyToBuffer'; + ReadMethod['CopyToTexture'] = 'CopyToTexture'; + ReadMethod['DepthTest'] = 'DepthTest'; + ReadMethod['StencilTest'] = 'StencilTest'; + ReadMethod['ColorBlending'] = 'ColorBlending'; + ReadMethod['Storage'] = 'Storage'; +})(ReadMethod || (ReadMethod = {})); + +const kMipLevelCounts = [1, 5]; + +// For each mip level count, define the mip ranges to leave uninitialized. +const kUninitializedMipRangesToTest = { + 1: [{ begin: 0, end: 1 }], // Test the only mip + 5: [ + { begin: 0, end: 2 }, + { begin: 3, end: 4 }, + ], + // Test a range and a single mip +}; + +// Test with these sample counts. + +const kSampleCounts = [1, 4]; + +// Test with these slice counts. This means the depth of a 3d texture or the number +// or layers in a 2D or a 1D texture array. + +// For each slice count, define the slices to leave uninitialized. +const kUninitializedSliceRangesToTest = { + 1: [{ begin: 0, end: 1 }], // Test the only slice + 7: [ + { begin: 2, end: 4 }, + { begin: 6, end: 7 }, + ], + // Test a range and a single slice +}; + +// Test with these combinations of texture dimension and sliceCount. +const kCreationSizes = [ + // { dimension: '1d', sliceCount: 7 }, // TODO: 1d textures + { dimension: '2d', sliceCount: 1 }, // 2d textures + { dimension: '2d', sliceCount: 7 }, // 2d array textures + // { dimension: '3d', sliceCount: 7 }, // TODO: 3d textures +]; + +// Enums to abstract over color / depth / stencil values in textures. Depending on the texture format, +// the data for each value may have a different representation. These enums are converted to a +// representation such that their values can be compared. ex.) An integer is needed to upload to an +// unsigned normalized format, but its value is read as a float in the shader. +export let InitializedState; +(function (InitializedState) { + InitializedState[(InitializedState['Canary'] = 0)] = 'Canary'; + InitializedState[(InitializedState['Zero'] = 1)] = 'Zero'; +})(InitializedState || (InitializedState = {})); + +export function initializedStateAsFloat(state) { + switch (state) { + case InitializedState.Zero: + return 0; + case InitializedState.Canary: + return 1; + default: + unreachable(); + } +} + +export function initializedStateAsUint(state) { + switch (state) { + case InitializedState.Zero: + return 0; + case InitializedState.Canary: + return 255; + default: + unreachable(); + } +} + +export function initializedStateAsSint(state) { + switch (state) { + case InitializedState.Zero: + return 0; + case InitializedState.Canary: + return -1; + default: + unreachable(); + } +} + +export function initializedStateAsColor(state, format) { + let value; + if (format.indexOf('uint') !== -1) { + value = initializedStateAsUint(state); + } else if (format.indexOf('sint') !== -1) { + value = initializedStateAsSint(state); + } else { + value = initializedStateAsFloat(state); + } + return [value, value, value, value]; +} + +export function initializedStateAsDepth(state) { + switch (state) { + case InitializedState.Zero: + return 0; + case InitializedState.Canary: + return 1; + default: + unreachable(); + } +} + +export function initializedStateAsStencil(state) { + switch (state) { + case InitializedState.Zero: + return 0; + case InitializedState.Canary: + return 42; + default: + unreachable(); + } +} + +function getRequiredTextureUsage(format, sampleCount, uninitializeMethod, readMethod) { + let usage = GPUTextureUsage.COPY_DST; + + switch (uninitializeMethod) { + case UninitializeMethod.Creation: + break; + case UninitializeMethod.StoreOpClear: + usage |= GPUTextureUsage.OUTPUT_ATTACHMENT; + break; + default: + unreachable(); + } + + switch (readMethod) { + case ReadMethod.CopyToBuffer: + case ReadMethod.CopyToTexture: + usage |= GPUTextureUsage.COPY_SRC; + break; + case ReadMethod.Sample: + usage |= GPUTextureUsage.SAMPLED; + break; + case ReadMethod.Storage: + usage |= GPUTextureUsage.STORAGE; + break; + case ReadMethod.DepthTest: + case ReadMethod.StencilTest: + case ReadMethod.ColorBlending: + usage |= GPUTextureUsage.OUTPUT_ATTACHMENT; + break; + default: + unreachable(); + } + + if (sampleCount > 1) { + // Copies to multisampled textures are not allowed. We need OutputAttachment to initialize + // canary data in multisampled textures. + usage |= GPUTextureUsage.OUTPUT_ATTACHMENT; + } + + if (!kTextureFormatInfo[format].copyable) { + // Copies are not possible. We need OutputAttachment to initialize + // canary data. + assert(kTextureFormatInfo[format].renderable); + usage |= GPUTextureUsage.OUTPUT_ATTACHMENT; + } + + return usage; +} + +export class TextureZeroInitTest extends GPUTest { + constructor(rec, params) { + super(rec, params); + _defineProperty(this, 'stateToTexelComponents', void 0); + + const stateToTexelComponents = state => { + const [R, G, B, A] = initializedStateAsColor(state, this.params.format); + return { + R, + G, + B, + A, + Depth: initializedStateAsDepth(state), + Stencil: initializedStateAsStencil(state), + }; + }; + + this.stateToTexelComponents = { + [InitializedState.Zero]: stateToTexelComponents(InitializedState.Zero), + [InitializedState.Canary]: stateToTexelComponents(InitializedState.Canary), + }; + } + + get params() { + return super.params; + } + + get textureWidth() { + let width = 1 << this.params.mipLevelCount; + if (this.params.nonPowerOfTwo) { + width = 2 * width - 1; + } + return width; + } + + get textureHeight() { + let height = 1 << this.params.mipLevelCount; + if (this.params.nonPowerOfTwo) { + height = 2 * height - 1; + } + return height; + } + + // Used to iterate subresources and check that their uninitialized contents are zero when accessed + *iterateUninitializedSubresources() { + for (const mipRange of kUninitializedMipRangesToTest[this.params.mipLevelCount]) { + for (const sliceRange of kUninitializedSliceRangesToTest[this.params.sliceCount]) { + yield new SubresourceRange({ mipRange, sliceRange }); + } + } + } + + // Used to iterate and initialize other subresources not checked for zero-initialization. + // Zero-initialization of uninitialized subresources should not have side effects on already + // initialized subresources. + *iterateInitializedSubresources() { + const uninitialized = new Array(this.params.mipLevelCount); + for (let level = 0; level < uninitialized.length; ++level) { + uninitialized[level] = new Array(this.params.sliceCount); + } + for (const subresources of this.iterateUninitializedSubresources()) { + for (const { level, slice } of subresources.each()) { + uninitialized[level][slice] = true; + } + } + for (let level = 0; level < uninitialized.length; ++level) { + for (let slice = 0; slice < uninitialized[level].length; ++slice) { + if (!uninitialized[level][slice]) { + yield new SubresourceRange({ + mipRange: { begin: level, count: 1 }, + sliceRange: { begin: slice, count: 1 }, + }); + } + } + } + } + + *generateTextureViewDescriptorsForRendering(aspect, subresourceRange) { + const viewDescriptor = { + dimension: '2d', + aspect, + }; + + if (subresourceRange === undefined) { + return viewDescriptor; + } + + for (const { level, slice } of subresourceRange.each()) { + yield { + ...viewDescriptor, + baseMipLevel: level, + mipLevelCount: 1, + baseArrayLayer: slice, + arrayLayerCount: 1, + }; + } + } + + initializeWithStoreOp(state, texture, subresourceRange) { + const commandEncoder = this.device.createCommandEncoder(); + for (const viewDescriptor of this.generateTextureViewDescriptorsForRendering( + this.params.aspect, + subresourceRange + )) { + if (kTextureFormatInfo[this.params.format].color) { + commandEncoder + .beginRenderPass({ + colorAttachments: [ + { + attachment: texture.createView(viewDescriptor), + storeOp: 'store', + loadValue: initializedStateAsColor(state, this.params.format), + }, + ], + }) + .endPass(); + } else { + commandEncoder + .beginRenderPass({ + colorAttachments: [], + depthStencilAttachment: { + attachment: texture.createView(viewDescriptor), + depthStoreOp: 'store', + depthLoadValue: initializedStateAsDepth(state), + stencilStoreOp: 'store', + stencilLoadValue: initializedStateAsStencil(state), + }, + }) + .endPass(); + } + } + this.queue.submit([commandEncoder.finish()]); + } + + initializeWithCopy(texture, state, subresourceRange) { + if (this.params.dimension === '1d' || this.params.dimension === '3d') { + // TODO: https://github.com/gpuweb/gpuweb/issues/69 + // Copies with 1D and 3D textures are not yet specified + unreachable(); + } + + const firstSubresource = subresourceRange.each().next().value; + assert(typeof firstSubresource !== 'undefined'); + + const largestWidth = this.textureWidth >> firstSubresource.level; + const largestHeight = this.textureHeight >> firstSubresource.level; + + const texelData = new Uint8Array( + getTexelDataRepresentation(this.params.format).getBytes(this.stateToTexelComponents[state]) + ); + + const { buffer, bytesPerRow, rowsPerImage } = createTextureUploadBuffer( + texelData, + this.device, + this.params.format, + this.params.dimension, + [largestWidth, largestHeight, 1] + ); + + const commandEncoder = this.device.createCommandEncoder(); + + for (const { level, slice } of subresourceRange.each()) { + const width = this.textureWidth >> level; + const height = this.textureHeight >> level; + + commandEncoder.copyBufferToTexture( + { + buffer, + bytesPerRow, + rowsPerImage, + }, + + { texture, mipLevel: level, origin: { x: 0, y: 0, z: slice } }, + { width, height, depth: 1 } + ); + } + this.queue.submit([commandEncoder.finish()]); + buffer.destroy(); + } + + initializeTexture(texture, state, subresourceRange) { + if (this.params.sampleCount > 1 || !kTextureFormatInfo[this.params.format].copyable) { + // Copies to multisampled textures not yet specified. + // Use a storeOp for now. + assert(kTextureFormatInfo[this.params.format].renderable); + this.initializeWithStoreOp(state, texture, subresourceRange); + } else { + this.initializeWithCopy(texture, state, subresourceRange); + } + } + + discardTexture(texture, subresourceRange) { + const commandEncoder = this.device.createCommandEncoder(); + + for (const desc of this.generateTextureViewDescriptorsForRendering( + this.params.aspect, + subresourceRange + )) { + if (kTextureFormatInfo[this.params.format].color) { + commandEncoder + .beginRenderPass({ + colorAttachments: [ + { + attachment: texture.createView(desc), + storeOp: 'clear', + loadValue: 'load', + }, + ], + }) + .endPass(); + } else { + commandEncoder + .beginRenderPass({ + colorAttachments: [], + depthStencilAttachment: { + attachment: texture.createView(desc), + depthStoreOp: 'clear', + depthLoadValue: 'load', + stencilStoreOp: 'clear', + stencilLoadValue: 'load', + }, + }) + .endPass(); + } + } + this.queue.submit([commandEncoder.finish()]); + } + + static generateParams(readMethods) { + return ( + // TODO: Consider making a list of "valid" texture descriptors in capability_info. + params() + .combine(poptions('format', kTextureFormats)) + .combine(poptions('aspect', kTextureAspects)) + .unless( + ({ format, aspect }) => + (aspect === 'depth-only' && !kTextureFormatInfo[format].depth) || + (aspect === 'stencil-only' && !kTextureFormatInfo[format].stencil) + ) + .combine(poptions('mipLevelCount', kMipLevelCounts)) + .combine(poptions('sampleCount', kSampleCounts)) + // Multisampled textures may only have one mip + .unless(({ sampleCount, mipLevelCount }) => sampleCount > 1 && mipLevelCount > 1) + .combine(poptions('uninitializeMethod', kUninitializeMethods)) + .combine(poptions('readMethod', readMethods)) + .unless( + ({ readMethod, format }) => + // It doesn't make sense to copy from a packed depth format. + // This is not specified yet, but it will probably be disallowed as the bits may + // be vendor-specific. + // TODO: Test copying out of the stencil aspect. + (readMethod === ReadMethod.CopyToBuffer || readMethod === ReadMethod.CopyToTexture) && + (format === 'depth24plus' || format === 'depth24plus-stencil8') + ) + .unless( + ({ readMethod, format }) => + (readMethod === ReadMethod.DepthTest && !kTextureFormatInfo[format].depth) || + (readMethod === ReadMethod.StencilTest && !kTextureFormatInfo[format].stencil) || + (readMethod === ReadMethod.ColorBlending && !kTextureFormatInfo[format].color) || + // TODO: Test with depth sampling + (readMethod === ReadMethod.Sample && kTextureFormatInfo[format].depth) + ) + .unless( + ({ readMethod, sampleCount }) => + // We can only read from multisampled textures by sampling. + sampleCount > 1 && + (readMethod === ReadMethod.CopyToBuffer || readMethod === ReadMethod.CopyToTexture) + ) + .combine(kCreationSizes) + // Multisampled 3D / 2D array textures not supported. + .unless(({ sampleCount, sliceCount }) => sampleCount > 1 && sliceCount > 1) + .filter(({ format, sampleCount, uninitializeMethod, readMethod }) => { + const usage = getRequiredTextureUsage( + format, + sampleCount, + uninitializeMethod, + readMethod + ); + + if (usage & GPUTextureUsage.OUTPUT_ATTACHMENT && !kTextureFormatInfo[format].renderable) { + return false; + } + + if (usage & GPUTextureUsage.STORAGE && !kTextureFormatInfo[format].storage) { + return false; + } + + return true; + }) + .combine(pbool('nonPowerOfTwo')) + ); + } + + run() { + const { + format, + dimension, + mipLevelCount, + sliceCount, + sampleCount, + uninitializeMethod, + readMethod, + } = this.params; + + const usage = getRequiredTextureUsage(format, sampleCount, uninitializeMethod, readMethod); + + const texture = this.device.createTexture({ + size: [this.textureWidth, this.textureHeight, sliceCount], + format, + dimension, + usage, + mipLevelCount, + sampleCount, + }); + + // Initialize some subresources with canary values + for (const subresourceRange of this.iterateInitializedSubresources()) { + this.initializeTexture(texture, InitializedState.Canary, subresourceRange); + } + + switch (uninitializeMethod) { + case UninitializeMethod.Creation: + break; + case UninitializeMethod.StoreOpClear: + // Initialize the rest of the resources. + for (const subresourceRange of this.iterateUninitializedSubresources()) { + this.initializeTexture(texture, InitializedState.Canary, subresourceRange); + } + // Then use a store op to discard their contents. + for (const subresourceRange of this.iterateUninitializedSubresources()) { + this.discardTexture(texture, subresourceRange); + } + break; + default: + unreachable(); + } + + // Check that all uninitialized resources are zero. + for (const subresourceRange of this.iterateUninitializedSubresources()) { + this.checkContents(texture, InitializedState.Zero, subresourceRange); + } + + // Check the all other resources are unchanged. + for (const subresourceRange of this.iterateInitializedSubresources()) { + this.checkContents(texture, InitializedState.Canary, subresourceRange); + } + } +} diff --git a/tests/wpt/webgpu/tests/webgpu/webgpu/api/validation/createBindGroup.spec.js b/tests/wpt/webgpu/tests/webgpu/webgpu/api/validation/createBindGroup.spec.js new file mode 100644 index 00000000000..fa585038e39 --- /dev/null +++ b/tests/wpt/webgpu/tests/webgpu/webgpu/api/validation/createBindGroup.spec.js @@ -0,0 +1,303 @@ +/** + * AUTO-GENERATED - DO NOT EDIT. Source: https://github.com/gpuweb/cts + **/ export const description = ` +createBindGroup validation tests. +`; +import { poptions, params } from '../../../common/framework/params_builder.js'; +import { makeTestGroup } from '../../../common/framework/test_group.js'; +import { unreachable } from '../../../common/framework/util/util.js'; +import { + kBindingTypes, + kBindingTypeInfo, + kBindableResources, + kTextureUsages, + kTextureBindingTypes, + kTextureBindingTypeInfo, +} from '../../capability_info.js'; + +import { ValidationTest } from './validation_test.js'; + +function clone(descriptor) { + return JSON.parse(JSON.stringify(descriptor)); +} + +export const g = makeTestGroup(ValidationTest); + +g.test('binding_count_mismatch').fn(async t => { + const bindGroupLayout = t.device.createBindGroupLayout({ + entries: [{ binding: 0, visibility: GPUShaderStage.COMPUTE, type: 'storage-buffer' }], + }); + + const goodDescriptor = { + entries: [{ binding: 0, resource: { buffer: t.getStorageBuffer() } }], + layout: bindGroupLayout, + }; + + // Control case + t.device.createBindGroup(goodDescriptor); + + // Another binding is not expected. + const badDescriptor = { + entries: [ + { binding: 0, resource: { buffer: t.getStorageBuffer() } }, + // Another binding is added. + { binding: 1, resource: { buffer: t.getStorageBuffer() } }, + ], + + layout: bindGroupLayout, + }; + + t.expectValidationError(() => { + t.device.createBindGroup(badDescriptor); + }); +}); + +g.test('binding_must_be_present_in_layout').fn(async t => { + const bindGroupLayout = t.device.createBindGroupLayout({ + entries: [{ binding: 0, visibility: GPUShaderStage.COMPUTE, type: 'storage-buffer' }], + }); + + const goodDescriptor = { + entries: [{ binding: 0, resource: { buffer: t.getStorageBuffer() } }], + layout: bindGroupLayout, + }; + + // Control case + t.device.createBindGroup(goodDescriptor); + + // Binding index 0 must be present. + const badDescriptor = { + entries: [{ binding: 1, resource: { buffer: t.getStorageBuffer() } }], + layout: bindGroupLayout, + }; + + t.expectValidationError(() => { + t.device.createBindGroup(badDescriptor); + }); +}); + +g.test('buffer_binding_must_contain_exactly_one_buffer_of_its_type') + .params( + params() + .combine(poptions('bindingType', kBindingTypes)) + .combine(poptions('resourceType', kBindableResources)) + ) + .fn(t => { + const { bindingType, resourceType } = t.params; + const info = kBindingTypeInfo[bindingType]; + + const storageTextureFormat = info.resource === 'storageTex' ? 'rgba8unorm' : undefined; + const layout = t.device.createBindGroupLayout({ + entries: [ + { binding: 0, visibility: GPUShaderStage.COMPUTE, type: bindingType, storageTextureFormat }, + ], + }); + + const resource = t.getBindingResource(resourceType); + + const resourceBindingMatches = info.resource === resourceType; + t.expectValidationError(() => { + t.device.createBindGroup({ layout, entries: [{ binding: 0, resource }] }); + }, !resourceBindingMatches); + }); + +g.test('texture_binding_must_have_correct_usage') + .params( + params() + .combine(poptions('type', kTextureBindingTypes)) + .combine(poptions('usage', kTextureUsages)) + ) + .fn(async t => { + const { type, usage } = t.params; + const info = kTextureBindingTypeInfo[type]; + + const storageTextureFormat = info.resource === 'storageTex' ? 'rgba8unorm' : undefined; + const bindGroupLayout = t.device.createBindGroupLayout({ + entries: [{ binding: 0, visibility: GPUShaderStage.FRAGMENT, type, storageTextureFormat }], + }); + + const descriptor = { + size: { width: 16, height: 16, depth: 1 }, + format: 'rgba8unorm', + usage, + }; + + const shouldError = usage !== info.usage; + t.expectValidationError(() => { + t.device.createBindGroup({ + entries: [{ binding: 0, resource: t.device.createTexture(descriptor).createView() }], + layout: bindGroupLayout, + }); + }, shouldError); + }); + +g.test('texture_must_have_correct_component_type') + .params(poptions('textureComponentType', ['float', 'sint', 'uint'])) + .fn(async t => { + const { textureComponentType } = t.params; + + const bindGroupLayout = t.device.createBindGroupLayout({ + entries: [ + { + binding: 0, + visibility: GPUShaderStage.FRAGMENT, + type: 'sampled-texture', + textureComponentType, + }, + ], + }); + + // TODO: Test more texture component types. + let format; + if (textureComponentType === 'float') { + format = 'r8unorm'; + } else if (textureComponentType === 'sint') { + format = 'r8sint'; + } else if (textureComponentType === 'uint') { + format = 'r8uint'; + } else { + unreachable('Unexpected texture component type'); + } + + const goodDescriptor = { + size: { width: 16, height: 16, depth: 1 }, + format, + usage: GPUTextureUsage.SAMPLED, + }; + + // Control case + t.device.createBindGroup({ + entries: [ + { + binding: 0, + resource: t.device.createTexture(goodDescriptor).createView(), + }, + ], + + layout: bindGroupLayout, + }); + + function* mismatchedTextureFormats() { + if (textureComponentType !== 'float') { + yield 'r8unorm'; + } + if (textureComponentType !== 'sint') { + yield 'r8sint'; + } + if (textureComponentType !== 'uint') { + yield 'r8uint'; + } + } + + // Mismatched texture binding formats are not valid. + for (const mismatchedTextureFormat of mismatchedTextureFormats()) { + const badDescriptor = clone(goodDescriptor); + badDescriptor.format = mismatchedTextureFormat; + + t.expectValidationError(() => { + t.device.createBindGroup({ + entries: [{ binding: 0, resource: t.device.createTexture(badDescriptor).createView() }], + layout: bindGroupLayout, + }); + }); + } + }); + +// TODO: Write test for all dimensions. +g.test('texture_must_have_correct_dimension').fn(async t => { + const bindGroupLayout = t.device.createBindGroupLayout({ + entries: [ + { + binding: 0, + visibility: GPUShaderStage.FRAGMENT, + type: 'sampled-texture', + viewDimension: '2d', + }, + ], + }); + + const goodDescriptor = { + size: { width: 16, height: 16, depth: 1 }, + format: 'rgba8unorm', + usage: GPUTextureUsage.SAMPLED, + }; + + // Control case + t.device.createBindGroup({ + entries: [{ binding: 0, resource: t.device.createTexture(goodDescriptor).createView() }], + layout: bindGroupLayout, + }); + + // Mismatched texture binding formats are not valid. + const badDescriptor = clone(goodDescriptor); + badDescriptor.size.depth = 2; + + t.expectValidationError(() => { + t.device.createBindGroup({ + entries: [{ binding: 0, resource: t.device.createTexture(badDescriptor).createView() }], + layout: bindGroupLayout, + }); + }); +}); + +g.test('buffer_offset_and_size_for_bind_groups_match') + .params([ + { offset: 0, size: 512, _success: true }, // offset 0 is valid + { offset: 256, size: 256, _success: true }, // offset 256 (aligned) is valid + + // Touching the end of the buffer + { offset: 0, size: 1024, _success: true }, + { offset: 0, size: undefined, _success: true }, + { offset: 256 * 3, size: 256, _success: true }, + { offset: 256 * 3, size: undefined, _success: true }, + + // Zero-sized bindings + { offset: 0, size: 0, _success: true }, + { offset: 256, size: 0, _success: true }, + { offset: 1024, size: 0, _success: true }, + { offset: 1024, size: undefined, _success: true }, + + // Unaligned buffer offset is invalid + { offset: 1, size: 256, _success: false }, + { offset: 1, size: undefined, _success: false }, + { offset: 128, size: 256, _success: false }, + { offset: 255, size: 256, _success: false }, + + // Out-of-bounds + { offset: 256 * 5, size: 0, _success: false }, // offset is OOB + { offset: 0, size: 256 * 5, _success: false }, // size is OOB + { offset: 1024, size: 1, _success: false }, // offset+size is OOB + ]) + .fn(async t => { + const { offset, size, _success } = t.params; + + const bindGroupLayout = t.device.createBindGroupLayout({ + entries: [{ binding: 0, visibility: GPUShaderStage.COMPUTE, type: 'storage-buffer' }], + }); + + const buffer = t.device.createBuffer({ + size: 1024, + usage: GPUBufferUsage.STORAGE, + }); + + const descriptor = { + entries: [ + { + binding: 0, + resource: { buffer, offset, size }, + }, + ], + + layout: bindGroupLayout, + }; + + if (_success) { + // Control case + t.device.createBindGroup(descriptor); + } else { + // Buffer offset and/or size don't match in bind groups. + t.expectValidationError(() => { + t.device.createBindGroup(descriptor); + }); + } + }); diff --git a/tests/wpt/webgpu/tests/webgpu/webgpu/api/validation/createBindGroupLayout.spec.js b/tests/wpt/webgpu/tests/webgpu/webgpu/api/validation/createBindGroupLayout.spec.js new file mode 100644 index 00000000000..778ca6fb1b7 --- /dev/null +++ b/tests/wpt/webgpu/tests/webgpu/webgpu/api/validation/createBindGroupLayout.spec.js @@ -0,0 +1,335 @@ +/** + * AUTO-GENERATED - DO NOT EDIT. Source: https://github.com/gpuweb/cts + **/ export const description = ` +createBindGroupLayout validation tests. +`; +import { pbool, poptions, params } from '../../../common/framework/params_builder.js'; +import { makeTestGroup } from '../../../common/framework/test_group.js'; +import { + kBindingTypeInfo, + kBindingTypes, + kBufferBindingTypeInfo, + kMaxBindingsPerBindGroup, + kShaderStages, + kShaderStageCombinations, + kTextureBindingTypeInfo, + kTextureComponentTypes, + kTextureViewDimensions, +} from '../../capability_info.js'; + +import { ValidationTest } from './validation_test.js'; + +function clone(descriptor) { + return JSON.parse(JSON.stringify(descriptor)); +} + +export const g = makeTestGroup(ValidationTest); + +g.test('some_binding_index_was_specified_more_than_once').fn(async t => { + const goodDescriptor = { + entries: [ + { binding: 0, visibility: GPUShaderStage.COMPUTE, type: 'storage-buffer' }, + { binding: 1, visibility: GPUShaderStage.COMPUTE, type: 'storage-buffer' }, + ], + }; + + // Control case + t.device.createBindGroupLayout(goodDescriptor); + + const badDescriptor = clone(goodDescriptor); + badDescriptor.entries[1].binding = 0; + + // Binding index 0 can't be specified twice. + t.expectValidationError(() => { + t.device.createBindGroupLayout(badDescriptor); + }); +}); + +g.test('visibility_and_dynamic_offsets') + .params( + params() + .combine(poptions('type', kBindingTypes)) + .combine(pbool('hasDynamicOffset')) + .combine(poptions('visibility', kShaderStageCombinations)) + ) + .fn(async t => { + const { type, hasDynamicOffset, visibility } = t.params; + const info = kBindingTypeInfo[type]; + + const supportsDynamicOffset = kBindingTypeInfo[type].perPipelineLimitClass.maxDynamic > 0; + let success = true; + if (!supportsDynamicOffset && hasDynamicOffset) success = false; + if ((visibility & ~info.validStages) !== 0) success = false; + + // When hasDynamicOffset is false, it actually tests visibility. + t.expectValidationError(() => { + t.device.createBindGroupLayout({ + entries: [{ binding: 0, visibility, type, hasDynamicOffset }], + }); + }, !success); + }); + +g.test('min_buffer_binding_size') + .params( + params() + .combine(poptions('type', kBindingTypes)) + .combine(poptions('minBufferBindingSize', [undefined, 0, 4])) + ) + .fn(async t => { + const { type, minBufferBindingSize } = t.params; + + let success = false; + if ( + minBufferBindingSize === undefined || + minBufferBindingSize === 0 || + type in kBufferBindingTypeInfo + ) { + success = true; + } + + t.expectValidationError(() => { + t.device.createBindGroupLayout({ + entries: [{ binding: 0, visibility: GPUShaderStage.COMPUTE, type, minBufferBindingSize }], + }); + }, !success); + }); + +g.test('view_dimension') + .params( + params() + .combine(poptions('type', kBindingTypes)) + .combine(poptions('viewDimension', [undefined, ...kTextureViewDimensions])) + ) + .fn(async t => { + const { type, viewDimension } = t.params; + + const success = viewDimension === undefined || type in kTextureBindingTypeInfo; + + t.expectValidationError(() => { + t.device.createBindGroupLayout({ + entries: [{ binding: 0, visibility: GPUShaderStage.COMPUTE, type, viewDimension }], + }); + }, !success); + }); + +g.test('texture_component_type') + .params( + params() + .combine(poptions('type', kBindingTypes)) + .combine(poptions('textureComponentType', [undefined, ...kTextureComponentTypes])) + ) + .fn(async t => { + const { type, textureComponentType } = t.params; + + const success = + textureComponentType === undefined || kBindingTypeInfo[type].resource === 'sampledTex'; + + t.expectValidationError(() => { + t.device.createBindGroupLayout({ + entries: [{ binding: 0, visibility: GPUShaderStage.COMPUTE, type, textureComponentType }], + }); + }, !success); + }); + +g.test('multisampled') + .params( + params() + .combine(poptions('type', kBindingTypes)) + .combine(poptions('multisampled', [undefined, false, true])) + ) + .fn(async t => { + const { type, multisampled } = t.params; + + const success = multisampled === false || kBindingTypeInfo[type].resource === 'sampledTex'; + + t.expectValidationError(() => { + t.device.createBindGroupLayout({ + entries: [{ binding: 0, visibility: GPUShaderStage.COMPUTE, type, multisampled }], + }); + }, !success); + }); + +g.test('storage_texture_format') + .params( + params() + .combine(poptions('type', kBindingTypes)) + .combine(poptions('storageTextureFormat', [undefined, 'rgba8unorm'])) + ) + .fn(async t => { + const { type, storageTextureFormat } = t.params; + + const success = + storageTextureFormat === undefined || kBindingTypeInfo[type].resource === 'storageTex'; + + t.expectValidationError(() => { + t.device.createBindGroupLayout({ + entries: [{ binding: 0, visibility: GPUShaderStage.COMPUTE, type, storageTextureFormat }], + }); + }, !success); + }); + +g.test('number_of_dynamic_buffers_exceeds_the_maximum_value') + .params([ + { type: 'storage-buffer', maxDynamicBufferCount: 4 }, + { type: 'uniform-buffer', maxDynamicBufferCount: 8 }, + ]) + .fn(async t => { + const { type, maxDynamicBufferCount } = t.params; + + const maxDynamicBufferBindings = []; + for (let i = 0; i < maxDynamicBufferCount; i++) { + maxDynamicBufferBindings.push({ + binding: i, + visibility: GPUShaderStage.COMPUTE, + type, + hasDynamicOffset: true, + }); + } + + const goodDescriptor = { + entries: [ + ...maxDynamicBufferBindings, + { + binding: maxDynamicBufferBindings.length, + visibility: GPUShaderStage.COMPUTE, + type, + hasDynamicOffset: false, + }, + ], + }; + + // Control case + t.device.createBindGroupLayout(goodDescriptor); + + // Dynamic buffers exceed maximum in a bind group layout. + const badDescriptor = clone(goodDescriptor); + badDescriptor.entries[maxDynamicBufferCount].hasDynamicOffset = true; + + t.expectValidationError(() => { + t.device.createBindGroupLayout(badDescriptor); + }); + }); + +// One bind group layout will be filled with kPerStageBindingLimit[...] of the type |type|. +// For each item in the array returned here, a case will be generated which tests a pipeline +// layout with one extra bind group layout with one extra binding. That extra binding will have: +// +// - If extraTypeSame, any of the binding types which counts toward the same limit as |type|. +// (i.e. 'storage-buffer' <-> 'readonly-storage-buffer'). +// - Otherwise, an arbitrary other type. +function* pickExtraBindingTypes(bindingType, extraTypeSame) { + const info = kBindingTypeInfo[bindingType]; + if (extraTypeSame) { + for (const extraBindingType of kBindingTypes) { + if ( + info.perStageLimitClass.class === + kBindingTypeInfo[extraBindingType].perStageLimitClass.class + ) { + yield extraBindingType; + } + } + } else { + yield info.perStageLimitClass.class === 'sampler' ? 'sampled-texture' : 'sampler'; + } +} + +const kCasesForMaxResourcesPerStageTests = params() + .combine(poptions('maxedType', kBindingTypes)) + .combine(poptions('maxedVisibility', kShaderStages)) + .filter(p => (kBindingTypeInfo[p.maxedType].validStages & p.maxedVisibility) !== 0) + .expand(function* (p) { + for (const extraTypeSame of [true, false]) { + yield* poptions('extraType', pickExtraBindingTypes(p.maxedType, extraTypeSame)); + } + }) + .combine(poptions('extraVisibility', kShaderStages)) + .filter(p => (kBindingTypeInfo[p.extraType].validStages & p.extraVisibility) !== 0); + +// Should never fail unless kMaxBindingsPerBindGroup is exceeded, because the validation for +// resources-of-type-per-stage is in pipeline layout creation. +g.test('max_resources_per_stage,in_bind_group_layout') + .params(kCasesForMaxResourcesPerStageTests) + .fn(async t => { + const { maxedType, extraType, maxedVisibility, extraVisibility } = t.params; + const maxedTypeInfo = kBindingTypeInfo[maxedType]; + const maxedCount = maxedTypeInfo.perStageLimitClass.max; + const extraTypeInfo = kBindingTypeInfo[extraType]; + + const maxResourceBindings = []; + for (let i = 0; i < maxedCount; i++) { + maxResourceBindings.push({ + binding: i, + visibility: maxedVisibility, + type: maxedType, + storageTextureFormat: maxedTypeInfo.resource === 'storageTex' ? 'rgba8unorm' : undefined, + }); + } + + const goodDescriptor = { entries: maxResourceBindings }; + + // Control + t.device.createBindGroupLayout(goodDescriptor); + + const newDescriptor = clone(goodDescriptor); + newDescriptor.entries.push({ + binding: maxedCount, + visibility: extraVisibility, + type: extraType, + storageTextureFormat: extraTypeInfo.resource === 'storageTex' ? 'rgba8unorm' : undefined, + }); + + const shouldError = maxedCount >= kMaxBindingsPerBindGroup; + + t.expectValidationError(() => { + t.device.createBindGroupLayout(newDescriptor); + }, shouldError); + }); + +// One pipeline layout can have a maximum number of each type of binding *per stage* (which is +// different for each type). Test that the max works, then add one more binding of same-or-different +// type and same-or-different visibility. +g.test('max_resources_per_stage,in_pipeline_layout') + .params(kCasesForMaxResourcesPerStageTests) + .fn(async t => { + const { maxedType, extraType, maxedVisibility, extraVisibility } = t.params; + const maxedTypeInfo = kBindingTypeInfo[maxedType]; + const maxedCount = maxedTypeInfo.perStageLimitClass.max; + const extraTypeInfo = kBindingTypeInfo[extraType]; + + const maxResourceBindings = []; + for (let i = 0; i < maxedCount; i++) { + maxResourceBindings.push({ + binding: i, + visibility: maxedVisibility, + type: maxedType, + storageTextureFormat: maxedTypeInfo.resource === 'storageTex' ? 'rgba8unorm' : undefined, + }); + } + + const goodLayout = t.device.createBindGroupLayout({ entries: maxResourceBindings }); + + // Control + t.device.createPipelineLayout({ bindGroupLayouts: [goodLayout] }); + + const extraLayout = t.device.createBindGroupLayout({ + entries: [ + { + binding: 0, + visibility: extraVisibility, + type: extraType, + storageTextureFormat: extraTypeInfo.resource === 'storageTex' ? 'rgba8unorm' : undefined, + }, + ], + }); + + // Some binding types use the same limit, e.g. 'storage-buffer' and 'readonly-storage-buffer'. + const newBindingCountsTowardSamePerStageLimit = + (maxedVisibility & extraVisibility) !== 0 && + kBindingTypeInfo[maxedType].perStageLimitClass.class === + kBindingTypeInfo[extraType].perStageLimitClass.class; + const layoutExceedsPerStageLimit = newBindingCountsTowardSamePerStageLimit; + + t.expectValidationError(() => { + t.device.createPipelineLayout({ bindGroupLayouts: [goodLayout, extraLayout] }); + }, layoutExceedsPerStageLimit); + }); diff --git a/tests/wpt/webgpu/tests/webgpu/webgpu/api/validation/createPipelineLayout.spec.js b/tests/wpt/webgpu/tests/webgpu/webgpu/api/validation/createPipelineLayout.spec.js new file mode 100644 index 00000000000..689ddaec883 --- /dev/null +++ b/tests/wpt/webgpu/tests/webgpu/webgpu/api/validation/createPipelineLayout.spec.js @@ -0,0 +1,95 @@ +/** + * AUTO-GENERATED - DO NOT EDIT. Source: https://github.com/gpuweb/cts + **/ export const description = ` +createPipelineLayout validation tests. +`; +import { poptions, params } from '../../../common/framework/params_builder.js'; +import { makeTestGroup } from '../../../common/framework/test_group.js'; +import { kBindingTypeInfo } from '../../capability_info.js'; + +import { ValidationTest } from './validation_test.js'; + +function clone(descriptor) { + return JSON.parse(JSON.stringify(descriptor)); +} + +export const g = makeTestGroup(ValidationTest); + +g.test('number_of_dynamic_buffers_exceeds_the_maximum_value') + .params( + params() + .combine(poptions('visibility', [0, 2, 4, 6])) + .combine(poptions('type', ['uniform-buffer', 'storage-buffer', 'readonly-storage-buffer'])) + ) + .fn(async t => { + const { type, visibility } = t.params; + const { maxDynamic } = kBindingTypeInfo[type].perPipelineLimitClass; + + const maxDynamicBufferBindings = []; + for (let binding = 0; binding < maxDynamic; binding++) { + maxDynamicBufferBindings.push({ binding, visibility, type, hasDynamicOffset: true }); + } + + const maxDynamicBufferBindGroupLayout = t.device.createBindGroupLayout({ + entries: maxDynamicBufferBindings, + }); + + const goodDescriptor = { + entries: [{ binding: 0, visibility, type, hasDynamicOffset: false }], + }; + + const goodPipelineLayoutDescriptor = { + bindGroupLayouts: [ + maxDynamicBufferBindGroupLayout, + t.device.createBindGroupLayout(goodDescriptor), + ], + }; + + // Control case + t.device.createPipelineLayout(goodPipelineLayoutDescriptor); + + // Check dynamic buffers exceed maximum in pipeline layout. + const badDescriptor = clone(goodDescriptor); + badDescriptor.entries[0].hasDynamicOffset = true; + + const badPipelineLayoutDescriptor = { + bindGroupLayouts: [ + maxDynamicBufferBindGroupLayout, + t.device.createBindGroupLayout(badDescriptor), + ], + }; + + t.expectValidationError(() => { + t.device.createPipelineLayout(badPipelineLayoutDescriptor); + }); + }); + +g.test('number_of_bind_group_layouts_exceeds_the_maximum_value').fn(async t => { + const bindGroupLayoutDescriptor = { + entries: [], + }; + + // 4 is the maximum number of bind group layouts. + const maxBindGroupLayouts = [1, 2, 3, 4].map(() => + t.device.createBindGroupLayout(bindGroupLayoutDescriptor) + ); + + const goodPipelineLayoutDescriptor = { + bindGroupLayouts: maxBindGroupLayouts, + }; + + // Control case + t.device.createPipelineLayout(goodPipelineLayoutDescriptor); + + // Check bind group layouts exceed maximum in pipeline layout. + const badPipelineLayoutDescriptor = { + bindGroupLayouts: [ + ...maxBindGroupLayouts, + t.device.createBindGroupLayout(bindGroupLayoutDescriptor), + ], + }; + + t.expectValidationError(() => { + t.device.createPipelineLayout(badPipelineLayoutDescriptor); + }); +}); diff --git a/tests/wpt/webgpu/tests/webgpu/webgpu/api/validation/createRenderPipeline.spec.js b/tests/wpt/webgpu/tests/webgpu/webgpu/api/validation/createRenderPipeline.spec.js new file mode 100644 index 00000000000..4a72faacd6c --- /dev/null +++ b/tests/wpt/webgpu/tests/webgpu/webgpu/api/validation/createRenderPipeline.spec.js @@ -0,0 +1,234 @@ +/** + * AUTO-GENERATED - DO NOT EDIT. Source: https://github.com/gpuweb/cts + **/ export const description = ` +createRenderPipeline validation tests. +`; +import { poptions } from '../../../common/framework/params_builder.js'; +import { makeTestGroup } from '../../../common/framework/test_group.js'; +import { kTextureFormatInfo, kTextureFormats } from '../../capability_info.js'; + +import { ValidationTest } from './validation_test.js'; + +class F extends ValidationTest { + getDescriptor(options = {}) { + const defaultColorStates = [{ format: 'rgba8unorm' }]; + const { + primitiveTopology = 'triangle-list', + colorStates = defaultColorStates, + sampleCount = 1, + depthStencilState, + } = options; + + const format = colorStates.length ? colorStates[0].format : 'rgba8unorm'; + + return { + vertexStage: this.getVertexStage(), + fragmentStage: this.getFragmentStage(format), + layout: this.getPipelineLayout(), + primitiveTopology, + colorStates, + sampleCount, + depthStencilState, + }; + } + + getVertexStage() { + return { + module: this.makeShaderModule('vertex', { + glsl: ` + #version 450 + void main() { + gl_Position = vec4(0.0, 0.0, 0.0, 1.0); + } + `, + }), + + entryPoint: 'main', + }; + } + + getFragmentStage(format) { + let fragColorType; + if (format.endsWith('sint')) { + fragColorType = 'ivec4'; + } else if (format.endsWith('uint')) { + fragColorType = 'uvec4'; + } else { + fragColorType = 'vec4'; + } + + const glsl = ` + #version 450 + layout(location = 0) out ${fragColorType} fragColor; + void main() { + fragColor = ${fragColorType}(0.0, 1.0, 0.0, 1.0); + } + `; + + return { + module: this.makeShaderModule('fragment', { glsl }), + entryPoint: 'main', + }; + } + + getPipelineLayout() { + return this.device.createPipelineLayout({ bindGroupLayouts: [] }); + } + + createTexture(params) { + const { format, sampleCount } = params; + + return this.device.createTexture({ + size: { width: 4, height: 4, depth: 1 }, + usage: GPUTextureUsage.OUTPUT_ATTACHMENT, + format, + sampleCount, + }); + } +} + +export const g = makeTestGroup(F); + +g.test('basic_use_of_createRenderPipeline').fn(t => { + const descriptor = t.getDescriptor(); + + t.device.createRenderPipeline(descriptor); +}); + +g.test('at_least_one_color_state_is_required').fn(async t => { + const goodDescriptor = t.getDescriptor({ + colorStates: [{ format: 'rgba8unorm' }], + }); + + // Control case + t.device.createRenderPipeline(goodDescriptor); + + // Fail because lack of color states + const badDescriptor = t.getDescriptor({ + colorStates: [], + }); + + t.expectValidationError(() => { + t.device.createRenderPipeline(badDescriptor); + }); +}); + +g.test('color_formats_must_be_renderable') + .params(poptions('format', kTextureFormats)) + .fn(async t => { + const format = t.params.format; + const info = kTextureFormatInfo[format]; + + const descriptor = t.getDescriptor({ colorStates: [{ format }] }); + + if (info.renderable && info.color) { + // Succeeds when color format is renderable + t.device.createRenderPipeline(descriptor); + } else { + // Fails because when format is non-renderable + t.expectValidationError(() => { + t.device.createRenderPipeline(descriptor); + }); + } + }); + +g.test('sample_count_must_be_valid') + .params([ + { sampleCount: 0, _success: false }, + { sampleCount: 1, _success: true }, + { sampleCount: 2, _success: false }, + { sampleCount: 3, _success: false }, + { sampleCount: 4, _success: true }, + { sampleCount: 8, _success: false }, + { sampleCount: 16, _success: false }, + ]) + .fn(async t => { + const { sampleCount, _success } = t.params; + + const descriptor = t.getDescriptor({ sampleCount }); + + if (_success) { + // Succeeds when sample count is valid + t.device.createRenderPipeline(descriptor); + } else { + // Fails when sample count is not 4 or 1 + t.expectValidationError(() => { + t.device.createRenderPipeline(descriptor); + }); + } + }); + +g.test('sample_count_must_be_equal_to_the_one_of_every_attachment_in_the_render_pass') + .params([ + { attachmentSamples: 4, pipelineSamples: 4, _success: true }, // It is allowed to use multisampled render pass and multisampled render pipeline. + { attachmentSamples: 4, pipelineSamples: 1, _success: false }, // It is not allowed to use multisampled render pass and non-multisampled render pipeline. + { attachmentSamples: 1, pipelineSamples: 4, _success: false }, // It is not allowed to use non-multisampled render pass and multisampled render pipeline. + ]) + .fn(async t => { + const { attachmentSamples, pipelineSamples, _success } = t.params; + + const colorTexture = t.createTexture({ + format: 'rgba8unorm', + sampleCount: attachmentSamples, + }); + + const depthStencilTexture = t.createTexture({ + format: 'depth24plus-stencil8', + sampleCount: attachmentSamples, + }); + + const renderPassDescriptorWithoutDepthStencil = { + colorAttachments: [ + { + attachment: colorTexture.createView(), + loadValue: { r: 1.0, g: 0.0, b: 0.0, a: 1.0 }, + }, + ], + }; + + const renderPassDescriptorWithDepthStencilOnly = { + colorAttachments: [], + depthStencilAttachment: { + attachment: depthStencilTexture.createView(), + depthLoadValue: 1.0, + depthStoreOp: 'store', + stencilLoadValue: 0, + stencilStoreOp: 'store', + }, + }; + + const pipelineWithoutDepthStencil = t.device.createRenderPipeline( + t.getDescriptor({ + sampleCount: pipelineSamples, + }) + ); + + const pipelineWithDepthStencilOnly = t.device.createRenderPipeline( + t.getDescriptor({ + colorStates: [], + depthStencilState: { format: 'depth24plus-stencil8' }, + sampleCount: pipelineSamples, + }) + ); + + for (const { renderPassDescriptor, pipeline } of [ + { + renderPassDescriptor: renderPassDescriptorWithoutDepthStencil, + pipeline: pipelineWithoutDepthStencil, + }, + + { + renderPassDescriptor: renderPassDescriptorWithDepthStencilOnly, + pipeline: pipelineWithDepthStencilOnly, + }, + ]) { + const commandEncoder = t.device.createCommandEncoder(); + const renderPass = commandEncoder.beginRenderPass(renderPassDescriptor); + renderPass.setPipeline(pipeline); + renderPass.endPass(); + + t.expectValidationError(() => { + commandEncoder.finish(); + }, !_success); + } + }); diff --git a/tests/wpt/webgpu/tests/webgpu/webgpu/api/validation/createTexture.spec.js b/tests/wpt/webgpu/tests/webgpu/webgpu/api/validation/createTexture.spec.js new file mode 100644 index 00000000000..a9c7a8be01e --- /dev/null +++ b/tests/wpt/webgpu/tests/webgpu/webgpu/api/validation/createTexture.spec.js @@ -0,0 +1,145 @@ +/** + * AUTO-GENERATED - DO NOT EDIT. Source: https://github.com/gpuweb/cts + **/ export const description = ` +createTexture validation tests. +`; +import { poptions } from '../../../common/framework/params_builder.js'; +import { makeTestGroup } from '../../../common/framework/test_group.js'; +import { kTextureFormatInfo, kTextureFormats } from '../../capability_info.js'; + +import { ValidationTest } from './validation_test.js'; + +class F extends ValidationTest { + getDescriptor(options = {}) { + const { + width = 32, + height = 32, + arrayLayerCount = 1, + mipLevelCount = 1, + sampleCount = 1, + format = 'rgba8unorm', + } = options; + return { + size: { width, height, depth: arrayLayerCount }, + mipLevelCount, + sampleCount, + dimension: '2d', + format, + usage: GPUTextureUsage.OUTPUT_ATTACHMENT | GPUTextureUsage.SAMPLED, + }; + } +} + +export const g = makeTestGroup(F); + +g.test('validation_of_sampleCount') + .params([ + // TODO: Consider making a list of "valid"+"invalid" texture descriptors in capability_info. + { sampleCount: 0, _success: false }, // sampleCount of 0 is not allowed + { sampleCount: 1, _success: true }, // sampleCount of 1 is allowed + { sampleCount: 2, _success: false }, // sampleCount of 2 is not allowed + { sampleCount: 3, _success: false }, // sampleCount of 3 is not allowed + { sampleCount: 4, _success: true }, // sampleCount of 4 is allowed + { sampleCount: 8, _success: false }, // sampleCount of 8 is not allowed + { sampleCount: 16, _success: false }, // sampleCount of 16 is not allowed + { sampleCount: 4, mipLevelCount: 2, _success: false }, // multisampled multi-level not allowed + { sampleCount: 4, arrayLayerCount: 2, _success: false }, // multisampled multi-layer is not allowed + ]) + .fn(async t => { + const { sampleCount, mipLevelCount, arrayLayerCount, _success } = t.params; + + const descriptor = t.getDescriptor({ sampleCount, mipLevelCount, arrayLayerCount }); + + t.expectValidationError(() => { + t.device.createTexture(descriptor); + }, !_success); + }); + +g.test('validation_of_mipLevelCount') + .params([ + { width: 32, height: 32, mipLevelCount: 1, _success: true }, // mipLevelCount of 1 is allowed + { width: 32, height: 32, mipLevelCount: 0, _success: false }, // mipLevelCount of 0 is not allowed + { width: 32, height: 32, mipLevelCount: 6, _success: true }, // full mip chains are allowed (Mip level sizes: 32, 16, 8, 4, 2, 1) + { width: 31, height: 32, mipLevelCount: 6, _success: true }, // full mip chains are allowed (Mip level sizes: 31x32, 15x16, 7x8, 3x4, 1x2, 1x1) + { width: 32, height: 31, mipLevelCount: 6, _success: true }, // full mip chains are allowed (Mip level sizes: 32x31, 16x15, 8x7, 4x3, 2x1, 1x1) + { width: 31, height: 32, mipLevelCount: 7, _success: false }, // too big mip chains on width are disallowed (Mip level sizes: 31x32, 15x16, 7x8, 3x4, 1x2, 1x1, ?x?) + { width: 32, height: 31, mipLevelCount: 7, _success: false }, // too big mip chains on height are disallowed (Mip level sizes: 32x31, 16x15, 8x7, 4x3, 2x1, 1x1, ?x?) + { width: 32, height: 32, mipLevelCount: 100, _success: false }, // undefined shift check if miplevel is bigger than the integer bit width + { width: 32, height: 8, mipLevelCount: 6, _success: true }, // non square mip map halves the resolution until a 1x1 dimension. (Mip maps: 32 * 8, 16 * 4, 8 * 2, 4 * 1, 2 * 1, 1 * 1) + ]) + .fn(async t => { + const { width, height, mipLevelCount, _success } = t.params; + + const descriptor = t.getDescriptor({ width, height, mipLevelCount }); + + t.expectValidationError(() => { + t.device.createTexture(descriptor); + }, !_success); + }); + +g.test('it_is_valid_to_destroy_a_texture').fn(t => { + const descriptor = t.getDescriptor(); + const texture = t.device.createTexture(descriptor); + texture.destroy(); +}); + +g.test('it_is_valid_to_destroy_a_destroyed_texture').fn(t => { + const descriptor = t.getDescriptor(); + const texture = t.device.createTexture(descriptor); + texture.destroy(); + texture.destroy(); +}); + +g.test('it_is_invalid_to_submit_a_destroyed_texture_before_and_after_encode') + .params([ + { destroyBeforeEncode: false, destroyAfterEncode: false, _success: true }, + { destroyBeforeEncode: true, destroyAfterEncode: false, _success: false }, + { destroyBeforeEncode: false, destroyAfterEncode: true, _success: false }, + ]) + .fn(async t => { + const { destroyBeforeEncode, destroyAfterEncode, _success } = t.params; + + const descriptor = t.getDescriptor(); + const texture = t.device.createTexture(descriptor); + const textureView = texture.createView(); + + if (destroyBeforeEncode) { + texture.destroy(); + } + + const commandEncoder = t.device.createCommandEncoder(); + const renderPass = commandEncoder.beginRenderPass({ + colorAttachments: [ + { + attachment: textureView, + loadValue: { r: 1.0, g: 0.0, b: 0.0, a: 1.0 }, + }, + ], + }); + + renderPass.endPass(); + const commandBuffer = commandEncoder.finish(); + + if (destroyAfterEncode) { + texture.destroy(); + } + + t.expectValidationError(() => { + t.queue.submit([commandBuffer]); + }, !_success); + }); + +g.test('it_is_invalid_to_have_an_output_attachment_texture_with_non_renderable_format') + .params(poptions('format', kTextureFormats)) + .fn(async t => { + const format = t.params.format; + const info = kTextureFormatInfo[format]; + + const descriptor = t.getDescriptor({ width: 1, height: 1, format }); + + t.expectValidationError(() => { + t.device.createTexture(descriptor); + }, !info.renderable); + }); + +// TODO: Add tests for compressed texture formats diff --git a/tests/wpt/webgpu/tests/webgpu/webgpu/api/validation/createView.spec.js b/tests/wpt/webgpu/tests/webgpu/webgpu/api/validation/createView.spec.js new file mode 100644 index 00000000000..d5b16563c13 --- /dev/null +++ b/tests/wpt/webgpu/tests/webgpu/webgpu/api/validation/createView.spec.js @@ -0,0 +1,267 @@ +/** + * AUTO-GENERATED - DO NOT EDIT. Source: https://github.com/gpuweb/cts + **/ export const description = ` +createView validation tests. +`; +import { makeTestGroup } from '../../../common/framework/test_group.js'; + +import { ValidationTest } from './validation_test.js'; + +const ARRAY_LAYER_COUNT_2D = 6; +const MIP_LEVEL_COUNT = 6; +const FORMAT = 'rgba8unorm'; + +class F extends ValidationTest { + createTexture(options = {}) { + const { + width = 32, + height = 32, + arrayLayerCount = 1, + mipLevelCount = MIP_LEVEL_COUNT, + sampleCount = 1, + } = options; + + return this.device.createTexture({ + size: { width, height, depth: arrayLayerCount }, + mipLevelCount, + sampleCount, + dimension: '2d', + format: FORMAT, + usage: GPUTextureUsage.SAMPLED, + }); + } + + getDescriptor(options = {}) { + const { + format = FORMAT, + dimension = '2d', + baseMipLevel = 0, + mipLevelCount = MIP_LEVEL_COUNT, + baseArrayLayer = 0, + arrayLayerCount = 1, + } = options; + return { + format, + dimension, + baseMipLevel, + mipLevelCount, + baseArrayLayer, + arrayLayerCount, + }; + } +} + +export const g = makeTestGroup(F); + +g.test('creating_texture_view_on_a_2D_non_array_texture') + .params([ + { _success: true }, // default view works + { arrayLayerCount: 1, _success: true }, // it is OK to create a 2D texture view on a 2D texture + { arrayLayerCount: 2, _success: false }, // it is an error to view a layer past the end of the texture + { dimension: '2d-array', arrayLayerCount: 1, _success: true }, // it is OK to create a 1-layer 2D array texture view on a 2D texture + // mip level is in range + { mipLevelCount: 1, baseMipLevel: MIP_LEVEL_COUNT - 1, _success: true }, + { mipLevelCount: 2, baseMipLevel: MIP_LEVEL_COUNT - 2, _success: true }, + // baseMipLevel == k && mipLevelCount == 0 means to use levels k..end + { mipLevelCount: 0, baseMipLevel: 0, _success: true }, + { mipLevelCount: 0, baseMipLevel: 1, _success: true }, + { mipLevelCount: 0, baseMipLevel: MIP_LEVEL_COUNT - 1, _success: true }, + { mipLevelCount: 0, baseMipLevel: MIP_LEVEL_COUNT, _success: false }, + // it is an error to make the mip level out of range + { mipLevelCount: MIP_LEVEL_COUNT + 1, baseMipLevel: 0, _success: false }, + { mipLevelCount: MIP_LEVEL_COUNT, baseMipLevel: 1, _success: false }, + { mipLevelCount: 2, baseMipLevel: MIP_LEVEL_COUNT - 1, _success: false }, + { mipLevelCount: 1, baseMipLevel: MIP_LEVEL_COUNT, _success: false }, + ]) + .fn(async t => { + const { dimension = '2d', arrayLayerCount, mipLevelCount, baseMipLevel, _success } = t.params; + + const texture = t.createTexture({ arrayLayerCount: 1 }); + + const descriptor = t.getDescriptor({ + dimension, + arrayLayerCount, + mipLevelCount, + baseMipLevel, + }); + + t.expectValidationError(() => { + texture.createView(descriptor); + }, !_success); + }); + +g.test('creating_texture_view_on_a_2D_array_texture') + .params([ + { _success: true }, // default view works + { dimension: '2d', arrayLayerCount: 1, _success: true }, // it is OK to create a 2D texture view on a 2D array texture + { arrayLayerCount: ARRAY_LAYER_COUNT_2D, _success: true }, // it is OK to create a 2D array texture view on a 2D array texture + // baseArrayLayer == k && arrayLayerCount == 0 means to use layers k..end. + { arrayLayerCount: 0, baseArrayLayer: 0, _success: true }, + { arrayLayerCount: 0, baseArrayLayer: 1, _success: true }, + { arrayLayerCount: 0, baseArrayLayer: ARRAY_LAYER_COUNT_2D - 1, _success: true }, + { arrayLayerCount: 0, baseArrayLayer: ARRAY_LAYER_COUNT_2D, _success: false }, + // It is an error for the array layer range of the view to exceed that of the texture + { arrayLayerCount: ARRAY_LAYER_COUNT_2D + 1, baseArrayLayer: 0, _success: false }, + { arrayLayerCount: ARRAY_LAYER_COUNT_2D, baseArrayLayer: 1, _success: false }, + { arrayLayerCount: 2, baseArrayLayer: ARRAY_LAYER_COUNT_2D - 1, _success: false }, + { arrayLayerCount: 1, baseArrayLayer: ARRAY_LAYER_COUNT_2D, _success: false }, + ]) + .fn(async t => { + const { dimension = '2d-array', arrayLayerCount, baseArrayLayer, _success } = t.params; + + const texture = t.createTexture({ arrayLayerCount: ARRAY_LAYER_COUNT_2D }); + + const descriptor = t.getDescriptor({ + dimension, + arrayLayerCount, + baseArrayLayer, + }); + + t.expectValidationError(() => { + texture.createView(descriptor); + }, !_success); + }); + +g.test('Using_defaults_validates_the_same_as_setting_values_for_more_than_1_array_layer') + .params([ + { _success: true }, + { format: 'rgba8unorm', _success: true }, + { format: 'r8unorm', _success: false }, + { dimension: '2d-array', _success: true }, + { dimension: '2d', _success: false }, + { arrayLayerCount: ARRAY_LAYER_COUNT_2D, _success: false }, // setting array layers to non-0 means the dimensionality will default to 2D so by itself it causes an error. + { arrayLayerCount: ARRAY_LAYER_COUNT_2D, dimension: '2d-array', _success: true }, + { + arrayLayerCount: ARRAY_LAYER_COUNT_2D, + dimension: '2d-array', + mipLevelCount: MIP_LEVEL_COUNT, + _success: true, + }, + ]) + .fn(async t => { + const { format, dimension, arrayLayerCount, mipLevelCount, _success } = t.params; + + const texture = t.createTexture({ arrayLayerCount: ARRAY_LAYER_COUNT_2D }); + + const descriptor = { format, dimension, arrayLayerCount, mipLevelCount }; + + t.expectValidationError(() => { + texture.createView(descriptor); + }, !_success); + }); + +g.test('Using_defaults_validates_the_same_as_setting_values_for_only_1_array_layer') + .params([ + { _success: true }, + { format: 'rgba8unorm', _success: true }, + { format: 'r8unorm', _success: false }, + { dimension: '2d-array', _success: true }, + { dimension: '2d', _success: true }, + { arrayLayerCount: 0, _success: true }, + { arrayLayerCount: 1, _success: true }, + { arrayLayerCount: 2, _success: false }, + { mipLevelCount: MIP_LEVEL_COUNT, _success: true }, + { mipLevelCount: 1, _success: true }, + ]) + .fn(async t => { + const { format, dimension, arrayLayerCount, mipLevelCount, _success } = t.params; + + const texture = t.createTexture({ arrayLayerCount: 1 }); + + const descriptor = { format, dimension, arrayLayerCount, mipLevelCount }; + + t.expectValidationError(() => { + texture.createView(descriptor); + }, !_success); + }); + +g.test('creating_cube_map_texture_view') + .params([ + { dimension: 'cube', arrayLayerCount: 6, _success: true }, // it is OK to create a cube map texture view with arrayLayerCount == 6 + // it is an error to create a cube map texture view with arrayLayerCount != 6 + { dimension: 'cube', arrayLayerCount: 3, _success: false }, + { dimension: 'cube', arrayLayerCount: 7, _success: false }, + { dimension: 'cube', arrayLayerCount: 12, _success: false }, + { dimension: 'cube', _success: false }, + { dimension: 'cube-array', arrayLayerCount: 12, _success: true }, // it is OK to create a cube map array texture view with arrayLayerCount % 6 == 0 + // it is an error to create a cube map array texture view with arrayLayerCount % 6 != 0 + { dimension: 'cube-array', arrayLayerCount: 11, _success: false }, + { dimension: 'cube-array', arrayLayerCount: 13, _success: false }, + ]) + .fn(async t => { + const { dimension = '2d-array', arrayLayerCount, _success } = t.params; + + const texture = t.createTexture({ arrayLayerCount: 16 }); + + const descriptor = t.getDescriptor({ + dimension, + arrayLayerCount, + }); + + t.expectValidationError(() => { + texture.createView(descriptor); + }, !_success); + }); + +g.test('creating_cube_map_texture_view_with_a_non_square_texture') + .params([ + { dimension: 'cube', arrayLayerCount: 6 }, // it is an error to create a cube map texture view with width != height. + { dimension: 'cube-array', arrayLayerCount: 12 }, // it is an error to create a cube map array texture view with width != height. + ]) + .fn(async t => { + const { dimension, arrayLayerCount } = t.params; + + const nonSquareTexture = t.createTexture({ + arrayLayerCount: 18, + width: 32, + height: 16, + mipLevelCount: 5, + }); + + const descriptor = t.getDescriptor({ + dimension, + arrayLayerCount, + }); + + t.expectValidationError(() => { + nonSquareTexture.createView(descriptor); + }); + }); + +// TODO: add more tests when rules are fully implemented. +g.test('test_the_format_compatibility_rules_when_creating_a_texture_view').fn(async t => { + const texture = t.createTexture({ arrayLayerCount: 1 }); + + const descriptor = t.getDescriptor({ + format: 'depth24plus-stencil8', + }); + + // it is invalid to create a view in depth-stencil format on a RGBA texture + t.expectValidationError(() => { + texture.createView(descriptor); + }); +}); + +g.test('it_is_invalid_to_use_a_texture_view_created_from_a_destroyed_texture').fn(async t => { + const texture = t.createTexture({ arrayLayerCount: 1 }); + + const commandEncoder = t.device.createCommandEncoder(); + const renderPass = commandEncoder.beginRenderPass({ + colorAttachments: [ + { + attachment: texture.createView(), + loadValue: { r: 1.0, g: 0.0, b: 0.0, a: 1.0 }, + }, + ], + }); + + renderPass.endPass(); + + texture.destroy(); + + t.expectValidationError(() => { + commandEncoder.finish(); + }); +}); + +// TODO: Add tests for TextureAspect diff --git a/tests/wpt/webgpu/tests/webgpu/webgpu/api/validation/encoding/cmds/index_access.spec.js b/tests/wpt/webgpu/tests/webgpu/webgpu/api/validation/encoding/cmds/index_access.spec.js new file mode 100644 index 00000000000..b0eb5c7bc6c --- /dev/null +++ b/tests/wpt/webgpu/tests/webgpu/webgpu/api/validation/encoding/cmds/index_access.spec.js @@ -0,0 +1,135 @@ +/** + * AUTO-GENERATED - DO NOT EDIT. Source: https://github.com/gpuweb/cts + **/ export const description = ` +indexed draws validation tests. +`; +import { params, poptions, pbool } from '../../../../../common/framework/params_builder.js'; +import { makeTestGroup } from '../../../../../common/framework/test_group.js'; + +import { ValidationTest } from './../../validation_test.js'; + +class F extends ValidationTest { + createIndexBuffer() { + const indexArray = new Uint32Array([0, 1, 2, 3, 1, 2]); + + const [indexBuffer, indexMapping] = this.device.createBufferMapped({ + size: indexArray.byteLength, + usage: GPUBufferUsage.INDEX, + }); + + new Uint32Array(indexMapping).set(indexArray); + indexBuffer.unmap(); + + return indexBuffer; + } + + createRenderPipeline() { + const vertexModule = this.makeShaderModule('vertex', { + glsl: ` + #version 450 + void main() { + gl_Position = vec4(0.0, 0.0, 0.0, 1.0); + } + `, + }); + + const fragmentModule = this.makeShaderModule('fragment', { + glsl: ` + #version 450 + layout(location = 0) out vec4 fragColor; + void main() { + fragColor = vec4(0.0, 1.0, 0.0, 1.0); + } + `, + }); + + return this.device.createRenderPipeline({ + layout: this.device.createPipelineLayout({ bindGroupLayouts: [] }), + vertexStage: { module: vertexModule, entryPoint: 'main' }, + fragmentStage: { module: fragmentModule, entryPoint: 'main' }, + primitiveTopology: 'triangle-strip', + colorStates: [{ format: 'rgba8unorm' }], + }); + } + + beginRenderPass(encoder) { + const colorAttachment = this.device.createTexture({ + format: 'rgba8unorm', + size: { width: 1, height: 1, depth: 1 }, + usage: GPUTextureUsage.OUTPUT_ATTACHMENT, + }); + + return encoder.beginRenderPass({ + colorAttachments: [ + { + attachment: colorAttachment.createView(), + loadValue: { r: 0.0, g: 0.0, b: 0.0, a: 1.0 }, + storeOp: 'store', + }, + ], + }); + } + + drawIndexed(indexCount, instanceCount, firstIndex, baseVertex, firstInstance) { + const indexBuffer = this.createIndexBuffer(); + + const pipeline = this.createRenderPipeline(); + + const encoder = this.device.createCommandEncoder(); + const pass = this.beginRenderPass(encoder); + pass.setPipeline(pipeline); + pass.setIndexBuffer(indexBuffer); + pass.drawIndexed(indexCount, instanceCount, firstIndex, baseVertex, firstInstance); + pass.endPass(); + + this.device.defaultQueue.submit([encoder.finish()]); + } + + drawIndexedIndirect(bufferArray, indirectOffset) { + const [indirectBuffer, indirectMapping] = this.device.createBufferMapped({ + size: bufferArray.byteLength, + usage: GPUBufferUsage.INDIRECT, + }); + + new Uint32Array(indirectMapping).set(bufferArray); + indirectBuffer.unmap(); + + const indexBuffer = this.createIndexBuffer(); + + const pipeline = this.createRenderPipeline(); + + const encoder = this.device.createCommandEncoder(); + const pass = this.beginRenderPass(encoder); + pass.setPipeline(pipeline); + pass.setIndexBuffer(indexBuffer, 0); + pass.drawIndexedIndirect(indirectBuffer, indirectOffset); + pass.endPass(); + + this.device.defaultQueue.submit([encoder.finish()]); + } +} + +export const g = makeTestGroup(F); + +g.test('out_of_bounds') + .params( + params() + .combine(pbool('indirect')) // indirect drawIndexed + .combine([ + { indexCount: 6, firstIndex: 1 }, // indexCount + firstIndex out of bound + { indexCount: 6, firstIndex: 6 }, // only firstIndex out of bound + { indexCount: 6, firstIndex: 10000 }, // firstIndex much larger than the bound + { indexCount: 7, firstIndex: 0 }, // only indexCount out of bound + { indexCount: 10000, firstIndex: 0 }, // indexCount much larger than the bound + ]) + .combine(poptions('instanceCount', [1, 10000])) // normal and large instanceCount + ) + .fn(t => { + const { indirect, indexCount, firstIndex, instanceCount } = t.params; + + if (indirect) { + t.drawIndexedIndirect(new Uint32Array([indexCount, instanceCount, firstIndex, 0, 0]), 0); + } else { + t.drawIndexed(indexCount, instanceCount, firstIndex, 0, 0); + } + }); diff --git a/tests/wpt/webgpu/tests/webgpu/webgpu/api/validation/error_scope.spec.js b/tests/wpt/webgpu/tests/webgpu/webgpu/api/validation/error_scope.spec.js new file mode 100644 index 00000000000..5523237daeb --- /dev/null +++ b/tests/wpt/webgpu/tests/webgpu/webgpu/api/validation/error_scope.spec.js @@ -0,0 +1,173 @@ +/** + * AUTO-GENERATED - DO NOT EDIT. Source: https://github.com/gpuweb/cts + **/ function _defineProperty(obj, key, value) { + if (key in obj) { + Object.defineProperty(obj, key, { + value: value, + enumerable: true, + configurable: true, + writable: true, + }); + } else { + obj[key] = value; + } + return obj; +} +export const description = ` +error scope validation tests. +`; +import { Fixture } from '../../../common/framework/fixture.js'; +import { getGPU } from '../../../common/framework/gpu/implementation.js'; +import { makeTestGroup } from '../../../common/framework/test_group.js'; +import { assert, raceWithRejectOnTimeout } from '../../../common/framework/util/util.js'; + +class F extends Fixture { + constructor(...args) { + super(...args); + _defineProperty(this, '_device', undefined); + } + + get device() { + assert(this._device !== undefined); + return this._device; + } + + async init() { + super.init(); + const gpu = getGPU(); + const adapter = await gpu.requestAdapter(); + this._device = await adapter.requestDevice(); + } + + createErrorBuffer() { + this.device.createBuffer({ + size: 1024, + usage: 0xffff, // Invalid GPUBufferUsage + }); + // TODO: Remove when chrome does it automatically. + this.device.defaultQueue.submit([]); + } + + // Expect an uncapturederror event to occur. Note: this MUST be awaited, because + // otherwise it could erroneously pass by capturing an error from later in the test. + async expectUncapturedError(fn) { + return this.immediateAsyncExpectation(() => { + // TODO: Make arbitrary timeout value a test runner variable + const TIMEOUT_IN_MS = 1000; + + const promise = new Promise(resolve => { + const eventListener = event => { + this.debug(`Got uncaptured error event with ${event.error}`); + resolve(event); + }; + + this.device.addEventListener('uncapturederror', eventListener, { once: true }); + }); + + fn(); + + return raceWithRejectOnTimeout( + promise, + TIMEOUT_IN_MS, + 'Timeout occurred waiting for uncaptured error' + ); + }); + } +} + +export const g = makeTestGroup(F); + +g.test('simple_case_where_the_error_scope_catches_an_error').fn(async t => { + t.device.pushErrorScope('validation'); + + t.createErrorBuffer(); + + const error = await t.device.popErrorScope(); + t.expect(error instanceof GPUValidationError); +}); + +g.test('errors_bubble_to_the_parent_scope_if_not_handled_by_the_current_scope').fn(async t => { + t.device.pushErrorScope('validation'); + t.device.pushErrorScope('out-of-memory'); + + t.createErrorBuffer(); + + { + const error = await t.device.popErrorScope(); + t.expect(error === null); + } + { + const error = await t.device.popErrorScope(); + t.expect(error instanceof GPUValidationError); + } +}); + +g.test('if_an_error_scope_matches_an_error_it_does_not_bubble_to_the_parent_scope').fn(async t => { + t.device.pushErrorScope('validation'); + t.device.pushErrorScope('validation'); + + t.createErrorBuffer(); + + { + const error = await t.device.popErrorScope(); + t.expect(error instanceof GPUValidationError); + } + { + const error = await t.device.popErrorScope(); + t.expect(error === null); + } +}); + +g.test('if_no_error_scope_handles_an_error_it_fires_an_uncapturederror_event').fn(async t => { + t.device.pushErrorScope('out-of-memory'); + + const uncapturedErrorEvent = await t.expectUncapturedError(() => { + t.createErrorBuffer(); + }); + t.expect(uncapturedErrorEvent.error instanceof GPUValidationError); + + const error = await t.device.popErrorScope(); + t.expect(error === null); +}); + +g.test('push,popping_sibling_error_scopes_must_be_balanced').fn(async t => { + { + const promise = t.device.popErrorScope(); + t.shouldReject('OperationError', promise); + } + + const promises = []; + for (let i = 0; i < 1000; i++) { + t.device.pushErrorScope('validation'); + promises.push(t.device.popErrorScope()); + } + const errors = await Promise.all(promises); + t.expect(errors.every(e => e === null)); + + { + const promise = t.device.popErrorScope(); + t.shouldReject('OperationError', promise); + } +}); + +g.test('push,popping_nested_error_scopes_must_be_balanced').fn(async t => { + { + const promise = t.device.popErrorScope(); + t.shouldReject('OperationError', promise); + } + + const promises = []; + for (let i = 0; i < 1000; i++) { + t.device.pushErrorScope('validation'); + } + for (let i = 0; i < 1000; i++) { + promises.push(t.device.popErrorScope()); + } + const errors = await Promise.all(promises); + t.expect(errors.every(e => e === null)); + + { + const promise = t.device.popErrorScope(); + t.shouldReject('OperationError', promise); + } +}); diff --git a/tests/wpt/webgpu/tests/webgpu/webgpu/api/validation/fences.spec.js b/tests/wpt/webgpu/tests/webgpu/webgpu/api/validation/fences.spec.js new file mode 100644 index 00000000000..e2d4c7eb922 --- /dev/null +++ b/tests/wpt/webgpu/tests/webgpu/webgpu/api/validation/fences.spec.js @@ -0,0 +1,88 @@ +/** + * AUTO-GENERATED - DO NOT EDIT. Source: https://github.com/gpuweb/cts + **/ export const description = ` +fences validation tests. +`; +import { makeTestGroup } from '../../../common/framework/test_group.js'; + +import { ValidationTest } from './validation_test.js'; + +export const g = makeTestGroup(ValidationTest); + +// TODO: Remove if https://github.com/gpuweb/gpuweb/issues/377 is decided +g.test('wait_on_a_fence_without_signaling_the_value_is_invalid').fn(async t => { + const fence = t.queue.createFence(); + + t.expectValidationError(() => { + const promise = fence.onCompletion(2); + t.shouldReject('OperationError', promise); + }); +}); + +// TODO: Remove if https://github.com/gpuweb/gpuweb/issues/377 is decided +g.test('wait_on_a_fence_with_a_value_greater_than_signaled_value_is_invalid').fn(async t => { + const fence = t.queue.createFence(); + t.queue.signal(fence, 2); + + t.expectValidationError(() => { + const promise = fence.onCompletion(3); + t.shouldReject('OperationError', promise); + }); +}); + +g.test('signal_a_value_lower_than_signaled_value_is_invalid').fn(async t => { + const fence = t.queue.createFence({ initialValue: 1 }); + + t.expectValidationError(() => { + t.queue.signal(fence, 0); + }); +}); + +g.test('signal_a_value_equal_to_signaled_value_is_invalid').fn(async t => { + const fence = t.queue.createFence({ initialValue: 1 }); + + t.expectValidationError(() => { + t.queue.signal(fence, 1); + }); +}); + +g.test('increasing_fence_value_by_more_than_1_succeeds').fn(async t => { + const fence = t.queue.createFence(); + + t.queue.signal(fence, 2); + await fence.onCompletion(2); + + t.queue.signal(fence, 6); + await fence.onCompletion(6); +}); + +g.test('signal_a_fence_on_a_different_device_than_it_was_created_on_is_invalid').fn(async t => { + const anotherDevice = await t.device.adapter.requestDevice(); + const fence = anotherDevice.defaultQueue.createFence(); + + t.expectValidationError(() => { + t.queue.signal(fence, 2); + }); +}); + +g.test('signal_a_fence_on_a_different_device_does_not_update_fence_signaled_value').fn(async t => { + const anotherDevice = await t.device.adapter.requestDevice(); + const fence = anotherDevice.defaultQueue.createFence({ initialValue: 1 }); + + t.expectValidationError(() => { + t.queue.signal(fence, 2); + }); + + t.expect(fence.getCompletedValue() === 1); + + anotherDevice.pushErrorScope('validation'); + + anotherDevice.defaultQueue.signal(fence, 2); + await fence.onCompletion(2); + t.expect(fence.getCompletedValue() === 2); + + const gpuValidationError = await anotherDevice.popErrorScope(); + if (gpuValidationError instanceof GPUValidationError) { + t.fail(`Captured validation error - ${gpuValidationError.message}`); + } +}); diff --git a/tests/wpt/webgpu/tests/webgpu/webgpu/api/validation/queue_submit.spec.js b/tests/wpt/webgpu/tests/webgpu/webgpu/api/validation/queue_submit.spec.js new file mode 100644 index 00000000000..2860a4f5318 --- /dev/null +++ b/tests/wpt/webgpu/tests/webgpu/webgpu/api/validation/queue_submit.spec.js @@ -0,0 +1,43 @@ +/** + * AUTO-GENERATED - DO NOT EDIT. Source: https://github.com/gpuweb/cts + **/ export const description = ` +queue submit validation tests. +`; +import { makeTestGroup } from '../../../common/framework/test_group.js'; + +import { ValidationTest } from './validation_test.js'; + +export const g = makeTestGroup(ValidationTest); + +g.test('submitting_with_a_mapped_buffer_is_disallowed').fn(async t => { + const buffer = t.device.createBuffer({ + size: 4, + usage: GPUBufferUsage.MAP_WRITE | GPUBufferUsage.COPY_SRC, + }); + + const targetBuffer = t.device.createBuffer({ + size: 4, + usage: GPUBufferUsage.COPY_DST, + }); + + const getCommandBuffer = () => { + const commandEncoder = t.device.createCommandEncoder(); + commandEncoder.copyBufferToBuffer(buffer, 0, targetBuffer, 0, 4); + return commandEncoder.finish(); + }; + + // Submitting when the buffer has never been mapped should succeed + t.queue.submit([getCommandBuffer()]); + + // Map the buffer, submitting when the buffer is mapped should fail + await buffer.mapWriteAsync(); + t.queue.submit([]); + + t.expectValidationError(() => { + t.queue.submit([getCommandBuffer()]); + }); + + // Unmap the buffer, queue submit should succeed + buffer.unmap(); + t.queue.submit([getCommandBuffer()]); +}); diff --git a/tests/wpt/webgpu/tests/webgpu/webgpu/api/validation/render_pass.spec.js b/tests/wpt/webgpu/tests/webgpu/webgpu/api/validation/render_pass.spec.js new file mode 100644 index 00000000000..b9db03bc86f --- /dev/null +++ b/tests/wpt/webgpu/tests/webgpu/webgpu/api/validation/render_pass.spec.js @@ -0,0 +1,152 @@ +/** + * AUTO-GENERATED - DO NOT EDIT. Source: https://github.com/gpuweb/cts + **/ export const description = ` +render pass validation tests. +`; +import { makeTestGroup } from '../../../common/framework/test_group.js'; + +import { ValidationTest } from './validation_test.js'; + +class F extends ValidationTest { + getUniformBuffer() { + return this.device.createBuffer({ + size: 8 * Float32Array.BYTES_PER_ELEMENT, + usage: GPUBufferUsage.UNIFORM, + }); + } + + createRenderPipeline(pipelineLayout) { + const vertexModule = this.makeShaderModule('vertex', { + glsl: `#version 450 + layout (set = 0, binding = 0) uniform vertexUniformBuffer { + mat2 transform; + }; + void main() { + const vec2 pos[3] = vec2[3](vec2(-1.f, -1.f), vec2(1.f, -1.f), vec2(-1.f, 1.f)); + gl_Position = vec4(transform * pos[gl_VertexIndex], 0.f, 1.f); + } + `, + }); + + const fragmentModule = this.makeShaderModule('fragment', { + glsl: ` + #version 450 + layout (set = 1, binding = 0) uniform fragmentUniformBuffer { + vec4 color; + }; + layout(location = 0) out vec4 fragColor; + void main() { + } + `, + }); + + const pipeline = this.device.createRenderPipeline({ + vertexStage: { module: vertexModule, entryPoint: 'main' }, + fragmentStage: { module: fragmentModule, entryPoint: 'main' }, + layout: pipelineLayout, + primitiveTopology: 'triangle-list', + colorStates: [{ format: 'rgba8unorm' }], + }); + + return pipeline; + } + + beginRenderPass(commandEncoder) { + const attachmentTexture = this.device.createTexture({ + format: 'rgba8unorm', + size: { width: 16, height: 16, depth: 1 }, + usage: GPUTextureUsage.OUTPUT_ATTACHMENT, + }); + + return commandEncoder.beginRenderPass({ + colorAttachments: [ + { + attachment: attachmentTexture.createView(), + loadValue: { r: 1.0, g: 0.0, b: 0.0, a: 1.0 }, + }, + ], + }); + } +} + +export const g = makeTestGroup(F); + +g.test('it_is_invalid_to_draw_in_a_render_pass_with_missing_bind_groups') + .params([ + { setBindGroup1: true, setBindGroup2: true, _success: true }, + { setBindGroup1: true, setBindGroup2: false, _success: false }, + { setBindGroup1: false, setBindGroup2: true, _success: false }, + { setBindGroup1: false, setBindGroup2: false, _success: false }, + ]) + .fn(async t => { + const { setBindGroup1, setBindGroup2, _success } = t.params; + + const uniformBuffer = t.getUniformBuffer(); + + const bindGroupLayout1 = t.device.createBindGroupLayout({ + entries: [ + { + binding: 0, + visibility: GPUShaderStage.VERTEX, + type: 'uniform-buffer', + }, + ], + }); + + const bindGroup1 = t.device.createBindGroup({ + entries: [ + { + binding: 0, + resource: { + buffer: uniformBuffer, + }, + }, + ], + + layout: bindGroupLayout1, + }); + + const bindGroupLayout2 = t.device.createBindGroupLayout({ + entries: [ + { + binding: 0, + visibility: GPUShaderStage.FRAGMENT, + type: 'uniform-buffer', + }, + ], + }); + + const bindGroup2 = t.device.createBindGroup({ + entries: [ + { + binding: 0, + resource: { + buffer: uniformBuffer, + }, + }, + ], + + layout: bindGroupLayout2, + }); + + const pipelineLayout = t.device.createPipelineLayout({ + bindGroupLayouts: [bindGroupLayout1, bindGroupLayout2], + }); + + const pipeline = t.createRenderPipeline(pipelineLayout); + + const commandEncoder = t.device.createCommandEncoder(); + const renderPass = t.beginRenderPass(commandEncoder); + renderPass.setPipeline(pipeline); + if (setBindGroup1) { + renderPass.setBindGroup(0, bindGroup1); + } + if (setBindGroup2) { + renderPass.setBindGroup(1, bindGroup2); + } + renderPass.draw(3, 1, 0, 0); + renderPass.endPass(); + t.expectValidationError(() => { + commandEncoder.finish(); + }, !_success); + }); diff --git a/tests/wpt/webgpu/tests/webgpu/webgpu/api/validation/render_pass/storeOp.spec.js b/tests/wpt/webgpu/tests/webgpu/webgpu/api/validation/render_pass/storeOp.spec.js new file mode 100644 index 00000000000..c43c6547bc8 --- /dev/null +++ b/tests/wpt/webgpu/tests/webgpu/webgpu/api/validation/render_pass/storeOp.spec.js @@ -0,0 +1,14 @@ +/** + * AUTO-GENERATED - DO NOT EDIT. Source: https://github.com/gpuweb/cts + **/ export const description = `API Validation Tests for RenderPass StoreOp. + + Test Coverage Needed: + + - Test that when depthReadOnly is true, depthStoreOp must be 'store' + + - Test that when stencilReadOnly is true, stencilStoreOp must be 'store'`; +import { makeTestGroup } from '../../../../common/framework/test_group.js'; + +import { ValidationTest } from './../validation_test.js'; + +export const g = makeTestGroup(ValidationTest); diff --git a/tests/wpt/webgpu/tests/webgpu/webgpu/api/validation/render_pass_descriptor.spec.js b/tests/wpt/webgpu/tests/webgpu/webgpu/api/validation/render_pass_descriptor.spec.js new file mode 100644 index 00000000000..6b2b8c54b78 --- /dev/null +++ b/tests/wpt/webgpu/tests/webgpu/webgpu/api/validation/render_pass_descriptor.spec.js @@ -0,0 +1,568 @@ +/** + * AUTO-GENERATED - DO NOT EDIT. Source: https://github.com/gpuweb/cts + **/ export const description = ` +render pass descriptor validation tests. +`; +import { makeTestGroup } from '../../../common/framework/test_group.js'; + +import { ValidationTest } from './validation_test.js'; + +class F extends ValidationTest { + createTexture(options = {}) { + const { + format = 'rgba8unorm', + width = 16, + height = 16, + arrayLayerCount = 1, + mipLevelCount = 1, + sampleCount = 1, + usage = GPUTextureUsage.OUTPUT_ATTACHMENT, + } = options; + + return this.device.createTexture({ + size: { width, height, depth: arrayLayerCount }, + format, + mipLevelCount, + sampleCount, + usage, + }); + } + + getColorAttachment(texture, textureViewDescriptor) { + const attachment = texture.createView(textureViewDescriptor); + + return { + attachment, + loadValue: { r: 1.0, g: 0.0, b: 0.0, a: 1.0 }, + }; + } + + getDepthStencilAttachment(texture, textureViewDescriptor) { + const attachment = texture.createView(textureViewDescriptor); + + return { + attachment, + depthLoadValue: 1.0, + depthStoreOp: 'store', + stencilLoadValue: 0, + stencilStoreOp: 'store', + }; + } + + async tryRenderPass(success, descriptor) { + const commandEncoder = this.device.createCommandEncoder(); + const renderPass = commandEncoder.beginRenderPass(descriptor); + renderPass.endPass(); + + this.expectValidationError(() => { + commandEncoder.finish(); + }, !success); + } +} + +export const g = makeTestGroup(F); + +g.test('a_render_pass_with_only_one_color_is_ok').fn(t => { + const colorTexture = t.createTexture({ format: 'rgba8unorm' }); + const descriptor = { + colorAttachments: [t.getColorAttachment(colorTexture)], + }; + + t.tryRenderPass(true, descriptor); +}); + +g.test('a_render_pass_with_only_one_depth_attachment_is_ok').fn(t => { + const depthStencilTexture = t.createTexture({ format: 'depth24plus-stencil8' }); + const descriptor = { + colorAttachments: [], + depthStencilAttachment: t.getDepthStencilAttachment(depthStencilTexture), + }; + + t.tryRenderPass(true, descriptor); +}); + +g.test('OOB_color_attachment_indices_are_handled') + .params([ + { colorAttachmentsCount: 4, _success: true }, // Control case + { colorAttachmentsCount: 5, _success: false }, // Out of bounds + ]) + .fn(async t => { + const { colorAttachmentsCount, _success } = t.params; + + const colorAttachments = []; + for (let i = 0; i < colorAttachmentsCount; i++) { + const colorTexture = t.createTexture(); + colorAttachments.push(t.getColorAttachment(colorTexture)); + } + + await t.tryRenderPass(_success, { colorAttachments }); + }); + +g.test('attachments_must_have_the_same_size').fn(async t => { + const colorTexture1x1A = t.createTexture({ width: 1, height: 1, format: 'rgba8unorm' }); + const colorTexture1x1B = t.createTexture({ width: 1, height: 1, format: 'rgba8unorm' }); + const colorTexture2x2 = t.createTexture({ width: 2, height: 2, format: 'rgba8unorm' }); + const depthStencilTexture1x1 = t.createTexture({ + width: 1, + height: 1, + format: 'depth24plus-stencil8', + }); + + const depthStencilTexture2x2 = t.createTexture({ + width: 2, + height: 2, + format: 'depth24plus-stencil8', + }); + + { + // Control case: all the same size (1x1) + const descriptor = { + colorAttachments: [ + t.getColorAttachment(colorTexture1x1A), + t.getColorAttachment(colorTexture1x1B), + ], + + depthStencilAttachment: t.getDepthStencilAttachment(depthStencilTexture1x1), + }; + + t.tryRenderPass(true, descriptor); + } + { + // One of the color attachments has a different size + const descriptor = { + colorAttachments: [ + t.getColorAttachment(colorTexture1x1A), + t.getColorAttachment(colorTexture2x2), + ], + }; + + await t.tryRenderPass(false, descriptor); + } + { + // The depth stencil attachment has a different size + const descriptor = { + colorAttachments: [ + t.getColorAttachment(colorTexture1x1A), + t.getColorAttachment(colorTexture1x1B), + ], + + depthStencilAttachment: t.getDepthStencilAttachment(depthStencilTexture2x2), + }; + + await t.tryRenderPass(false, descriptor); + } +}); + +g.test('attachments_must_match_whether_they_are_used_for_color_or_depth_stencil').fn(async t => { + const colorTexture = t.createTexture({ format: 'rgba8unorm' }); + const depthStencilTexture = t.createTexture({ format: 'depth24plus-stencil8' }); + + { + // Using depth-stencil for color + const descriptor = { + colorAttachments: [t.getColorAttachment(depthStencilTexture)], + }; + + await t.tryRenderPass(false, descriptor); + } + { + // Using color for depth-stencil + const descriptor = { + colorAttachments: [], + depthStencilAttachment: t.getDepthStencilAttachment(colorTexture), + }; + + await t.tryRenderPass(false, descriptor); + } +}); + +g.test('check_layer_count_for_color_or_depth_stencil') + .params([ + { arrayLayerCount: 5, baseArrayLayer: 0, _success: false }, // using 2D array texture view with arrayLayerCount > 1 is not allowed + { arrayLayerCount: 1, baseArrayLayer: 0, _success: true }, // using 2D array texture view that covers the first layer of the texture is OK + { arrayLayerCount: 1, baseArrayLayer: 9, _success: true }, // using 2D array texture view that covers the last layer is OK for depth stencil + ]) + .fn(async t => { + const { arrayLayerCount, baseArrayLayer, _success } = t.params; + + const ARRAY_LAYER_COUNT = 10; + const MIP_LEVEL_COUNT = 1; + const COLOR_FORMAT = 'rgba8unorm'; + const DEPTH_STENCIL_FORMAT = 'depth24plus-stencil8'; + + const colorTexture = t.createTexture({ + format: COLOR_FORMAT, + width: 32, + height: 32, + mipLevelCount: MIP_LEVEL_COUNT, + arrayLayerCount: ARRAY_LAYER_COUNT, + }); + + const depthStencilTexture = t.createTexture({ + format: DEPTH_STENCIL_FORMAT, + width: 32, + height: 32, + mipLevelCount: MIP_LEVEL_COUNT, + arrayLayerCount: ARRAY_LAYER_COUNT, + }); + + const baseTextureViewDescriptor = { + dimension: '2d-array', + baseArrayLayer, + arrayLayerCount, + baseMipLevel: 0, + mipLevelCount: MIP_LEVEL_COUNT, + }; + + { + // Check 2D array texture view for color + const textureViewDescriptor = { + ...baseTextureViewDescriptor, + format: COLOR_FORMAT, + }; + + const descriptor = { + colorAttachments: [t.getColorAttachment(colorTexture, textureViewDescriptor)], + }; + + await t.tryRenderPass(_success, descriptor); + } + { + // Check 2D array texture view for depth stencil + const textureViewDescriptor = { + ...baseTextureViewDescriptor, + format: DEPTH_STENCIL_FORMAT, + }; + + const descriptor = { + colorAttachments: [], + depthStencilAttachment: t.getDepthStencilAttachment( + depthStencilTexture, + textureViewDescriptor + ), + }; + + await t.tryRenderPass(_success, descriptor); + } + }); + +g.test('check_mip_level_count_for_color_or_depth_stencil') + .params([ + { mipLevelCount: 2, baseMipLevel: 0, _success: false }, // using 2D texture view with mipLevelCount > 1 is not allowed + { mipLevelCount: 1, baseMipLevel: 0, _success: true }, // using 2D texture view that covers the first level of the texture is OK + { mipLevelCount: 1, baseMipLevel: 3, _success: true }, // using 2D texture view that covers the last level of the texture is OK + ]) + .fn(async t => { + const { mipLevelCount, baseMipLevel, _success } = t.params; + + const ARRAY_LAYER_COUNT = 1; + const MIP_LEVEL_COUNT = 4; + const COLOR_FORMAT = 'rgba8unorm'; + const DEPTH_STENCIL_FORMAT = 'depth24plus-stencil8'; + + const colorTexture = t.createTexture({ + format: COLOR_FORMAT, + width: 32, + height: 32, + mipLevelCount: MIP_LEVEL_COUNT, + arrayLayerCount: ARRAY_LAYER_COUNT, + }); + + const depthStencilTexture = t.createTexture({ + format: DEPTH_STENCIL_FORMAT, + width: 32, + height: 32, + mipLevelCount: MIP_LEVEL_COUNT, + arrayLayerCount: ARRAY_LAYER_COUNT, + }); + + const baseTextureViewDescriptor = { + dimension: '2d', + baseArrayLayer: 0, + arrayLayerCount: ARRAY_LAYER_COUNT, + baseMipLevel, + mipLevelCount, + }; + + { + // Check 2D texture view for color + const textureViewDescriptor = { + ...baseTextureViewDescriptor, + format: COLOR_FORMAT, + }; + + const descriptor = { + colorAttachments: [t.getColorAttachment(colorTexture, textureViewDescriptor)], + }; + + await t.tryRenderPass(_success, descriptor); + } + { + // Check 2D texture view for depth stencil + const textureViewDescriptor = { + ...baseTextureViewDescriptor, + format: DEPTH_STENCIL_FORMAT, + }; + + const descriptor = { + colorAttachments: [], + depthStencilAttachment: t.getDepthStencilAttachment( + depthStencilTexture, + textureViewDescriptor + ), + }; + + await t.tryRenderPass(_success, descriptor); + } + }); + +g.test('it_is_invalid_to_set_resolve_target_if_color_attachment_is_non_multisampled').fn( + async t => { + const colorTexture = t.createTexture({ sampleCount: 1 }); + const resolveTargetTexture = t.createTexture({ sampleCount: 1 }); + + const descriptor = { + colorAttachments: [ + { + attachment: colorTexture.createView(), + resolveTarget: resolveTargetTexture.createView(), + loadValue: { r: 1.0, g: 0.0, b: 0.0, a: 1.0 }, + }, + ], + }; + + await t.tryRenderPass(false, descriptor); + } +); + +g.test('check_the_use_of_multisampled_textures_as_color_attachments').fn(async t => { + const colorTexture = t.createTexture({ sampleCount: 1 }); + const multisampledColorTexture = t.createTexture({ sampleCount: 4 }); + + { + // It is allowed to use a multisampled color attachment without setting resolve target + const descriptor = { + colorAttachments: [t.getColorAttachment(multisampledColorTexture)], + }; + + t.tryRenderPass(true, descriptor); + } + { + // It is not allowed to use multiple color attachments with different sample counts + const descriptor = { + colorAttachments: [ + t.getColorAttachment(colorTexture), + t.getColorAttachment(multisampledColorTexture), + ], + }; + + await t.tryRenderPass(false, descriptor); + } +}); + +g.test('it_is_invalid_to_use_a_multisampled_resolve_target').fn(async t => { + const multisampledColorTexture = t.createTexture({ sampleCount: 4 }); + const multisampledResolveTargetTexture = t.createTexture({ sampleCount: 4 }); + + const colorAttachment = t.getColorAttachment(multisampledColorTexture); + colorAttachment.resolveTarget = multisampledResolveTargetTexture.createView(); + + const descriptor = { + colorAttachments: [colorAttachment], + }; + + await t.tryRenderPass(false, descriptor); +}); + +g.test('it_is_invalid_to_use_a_resolve_target_with_array_layer_count_greater_than_1').fn( + async t => { + const multisampledColorTexture = t.createTexture({ sampleCount: 4 }); + const resolveTargetTexture = t.createTexture({ arrayLayerCount: 2 }); + + const colorAttachment = t.getColorAttachment(multisampledColorTexture); + colorAttachment.resolveTarget = resolveTargetTexture.createView(); + + const descriptor = { + colorAttachments: [colorAttachment], + }; + + await t.tryRenderPass(false, descriptor); + } +); + +g.test('it_is_invalid_to_use_a_resolve_target_with_mipmap_level_count_greater_than_1').fn( + async t => { + const multisampledColorTexture = t.createTexture({ sampleCount: 4 }); + const resolveTargetTexture = t.createTexture({ mipLevelCount: 2 }); + + const colorAttachment = t.getColorAttachment(multisampledColorTexture); + colorAttachment.resolveTarget = resolveTargetTexture.createView(); + + const descriptor = { + colorAttachments: [colorAttachment], + }; + + await t.tryRenderPass(false, descriptor); + } +); + +g.test('it_is_invalid_to_use_a_resolve_target_whose_usage_is_not_output_attachment').fn(async t => { + const multisampledColorTexture = t.createTexture({ sampleCount: 4 }); + const resolveTargetTexture = t.createTexture({ + usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.COPY_DST, + }); + + const colorAttachment = t.getColorAttachment(multisampledColorTexture); + colorAttachment.resolveTarget = resolveTargetTexture.createView(); + + const descriptor = { + colorAttachments: [colorAttachment], + }; + + await t.tryRenderPass(false, descriptor); +}); + +g.test('it_is_invalid_to_use_a_resolve_target_in_error_state').fn(async t => { + const ARRAY_LAYER_COUNT = 1; + + const multisampledColorTexture = t.createTexture({ sampleCount: 4 }); + const resolveTargetTexture = t.createTexture({ arrayLayerCount: ARRAY_LAYER_COUNT }); + + const colorAttachment = t.getColorAttachment(multisampledColorTexture); + t.expectValidationError(() => { + colorAttachment.resolveTarget = resolveTargetTexture.createView({ + dimension: '2d', + format: 'rgba8unorm', + baseArrayLayer: ARRAY_LAYER_COUNT + 1, + }); + }); + + const descriptor = { + colorAttachments: [colorAttachment], + }; + + await t.tryRenderPass(false, descriptor); +}); + +g.test('use_of_multisampled_attachment_and_non_multisampled_resolve_target_is_allowed').fn( + async t => { + const multisampledColorTexture = t.createTexture({ sampleCount: 4 }); + const resolveTargetTexture = t.createTexture({ sampleCount: 1 }); + + const colorAttachment = t.getColorAttachment(multisampledColorTexture); + colorAttachment.resolveTarget = resolveTargetTexture.createView(); + + const descriptor = { + colorAttachments: [colorAttachment], + }; + + t.tryRenderPass(true, descriptor); + } +); + +g.test('use_a_resolve_target_in_a_format_different_than_the_attachment_is_not_allowed').fn( + async t => { + const multisampledColorTexture = t.createTexture({ sampleCount: 4 }); + const resolveTargetTexture = t.createTexture({ format: 'bgra8unorm' }); + + const colorAttachment = t.getColorAttachment(multisampledColorTexture); + colorAttachment.resolveTarget = resolveTargetTexture.createView(); + + const descriptor = { + colorAttachments: [colorAttachment], + }; + + await t.tryRenderPass(false, descriptor); + } +); + +g.test('size_of_the_resolve_target_must_be_the_same_as_the_color_attachment').fn(async t => { + const size = 16; + const multisampledColorTexture = t.createTexture({ width: size, height: size, sampleCount: 4 }); + const resolveTargetTexture = t.createTexture({ + width: size * 2, + height: size * 2, + mipLevelCount: 2, + }); + + { + const resolveTargetTextureView = resolveTargetTexture.createView({ + baseMipLevel: 0, + mipLevelCount: 1, + }); + + const colorAttachment = t.getColorAttachment(multisampledColorTexture); + colorAttachment.resolveTarget = resolveTargetTextureView; + + const descriptor = { + colorAttachments: [colorAttachment], + }; + + await t.tryRenderPass(false, descriptor); + } + { + const resolveTargetTextureView = resolveTargetTexture.createView({ baseMipLevel: 1 }); + + const colorAttachment = t.getColorAttachment(multisampledColorTexture); + colorAttachment.resolveTarget = resolveTargetTextureView; + + const descriptor = { + colorAttachments: [colorAttachment], + }; + + t.tryRenderPass(true, descriptor); + } +}); + +g.test('check_depth_stencil_attachment_sample_counts_mismatch').fn(async t => { + const multisampledDepthStencilTexture = t.createTexture({ + sampleCount: 4, + format: 'depth24plus-stencil8', + }); + + { + // It is not allowed to use a depth stencil attachment whose sample count is different from the + // one of the color attachment + const depthStencilTexture = t.createTexture({ + sampleCount: 1, + format: 'depth24plus-stencil8', + }); + + const multisampledColorTexture = t.createTexture({ sampleCount: 4 }); + const descriptor = { + colorAttachments: [t.getColorAttachment(multisampledColorTexture)], + depthStencilAttachment: t.getDepthStencilAttachment(depthStencilTexture), + }; + + await t.tryRenderPass(false, descriptor); + } + { + const colorTexture = t.createTexture({ sampleCount: 1 }); + const descriptor = { + colorAttachments: [t.getColorAttachment(colorTexture)], + depthStencilAttachment: t.getDepthStencilAttachment(multisampledDepthStencilTexture), + }; + + await t.tryRenderPass(false, descriptor); + } + { + // It is allowed to use a multisampled depth stencil attachment whose sample count is equal to + // the one of the color attachment. + const multisampledColorTexture = t.createTexture({ sampleCount: 4 }); + const descriptor = { + colorAttachments: [t.getColorAttachment(multisampledColorTexture)], + depthStencilAttachment: t.getDepthStencilAttachment(multisampledDepthStencilTexture), + }; + + t.tryRenderPass(true, descriptor); + } + { + // It is allowed to use a multisampled depth stencil attachment with no color attachment + const descriptor = { + colorAttachments: [], + depthStencilAttachment: t.getDepthStencilAttachment(multisampledDepthStencilTexture), + }; + + t.tryRenderPass(true, descriptor); + } +}); diff --git a/tests/wpt/webgpu/tests/webgpu/webgpu/api/validation/setBindGroup.spec.js b/tests/wpt/webgpu/tests/webgpu/webgpu/api/validation/setBindGroup.spec.js new file mode 100644 index 00000000000..fca85a83b0e --- /dev/null +++ b/tests/wpt/webgpu/tests/webgpu/webgpu/api/validation/setBindGroup.spec.js @@ -0,0 +1,193 @@ +/** + * AUTO-GENERATED - DO NOT EDIT. Source: https://github.com/gpuweb/cts + **/ export const description = ` +setBindGroup validation tests. +`; +import { poptions, params } from '../../../common/framework/params_builder.js'; +import { makeTestGroup } from '../../../common/framework/test_group.js'; + +import { ValidationTest } from './validation_test.js'; + +class F extends ValidationTest { + makeAttachmentTexture() { + return this.device.createTexture({ + format: 'rgba8unorm', + size: { width: 16, height: 16, depth: 1 }, + usage: GPUTextureUsage.OUTPUT_ATTACHMENT, + }); + } + + testComputePass(bindGroup, dynamicOffsets) { + const encoder = this.device.createCommandEncoder(); + const computePass = encoder.beginComputePass(); + computePass.setBindGroup(0, bindGroup, dynamicOffsets); + computePass.endPass(); + encoder.finish(); + } + + testRenderPass(bindGroup, dynamicOffsets) { + const encoder = this.device.createCommandEncoder(); + const renderPass = encoder.beginRenderPass({ + colorAttachments: [ + { + attachment: this.makeAttachmentTexture().createView(), + loadValue: { r: 1.0, g: 0.0, b: 0.0, a: 1.0 }, + }, + ], + }); + + renderPass.setBindGroup(0, bindGroup, dynamicOffsets); + renderPass.endPass(); + encoder.finish(); + } + + testRenderBundle(bindGroup, dynamicOffsets) { + const encoder = this.device.createRenderBundleEncoder({ + colorFormats: ['rgba8unorm'], + }); + + encoder.setBindGroup(0, bindGroup, dynamicOffsets); + encoder.finish(); + } +} + +export const g = makeTestGroup(F); + +g.test('dynamic_offsets_passed_but_not_expected,compute_pass') + .params(poptions('type', ['compute', 'renderpass', 'renderbundle'])) + .fn(async t => { + const bindGroupLayout = t.device.createBindGroupLayout({ entries: [] }); + const bindGroup = t.device.createBindGroup({ layout: bindGroupLayout, entries: [] }); + + const { type } = t.params; + const dynamicOffsets = [0]; + + t.expectValidationError(() => { + if (type === 'compute') { + const encoder = t.device.createCommandEncoder(); + const computePass = encoder.beginComputePass(); + computePass.setBindGroup(0, bindGroup, dynamicOffsets); + computePass.endPass(); + encoder.finish(); + } else if (type === 'renderpass') { + const encoder = t.device.createCommandEncoder(); + const renderPass = encoder.beginRenderPass({ + colorAttachments: [ + { + attachment: t.makeAttachmentTexture().createView(), + loadValue: { r: 1.0, g: 0.0, b: 0.0, a: 1.0 }, + }, + ], + }); + + renderPass.setBindGroup(0, bindGroup, dynamicOffsets); + renderPass.endPass(); + encoder.finish(); + } else if (type === 'renderbundle') { + const encoder = t.device.createRenderBundleEncoder({ + colorFormats: ['rgba8unorm'], + }); + + encoder.setBindGroup(0, bindGroup, dynamicOffsets); + encoder.finish(); + } else { + t.fail(); + } + }); + }); + +g.test('dynamic_offsets_match_expectations_in_pass_encoder') + .params( + params() + .combine(poptions('type', ['compute', 'renderpass', 'renderbundle'])) + .combine([ + { dynamicOffsets: [256, 0], _success: true }, // Dynamic offsets aligned + { dynamicOffsets: [1, 2], _success: false }, // Dynamic offsets not aligned + + // Wrong number of dynamic offsets + { dynamicOffsets: [256, 0, 0], _success: false }, + { dynamicOffsets: [256], _success: false }, + { dynamicOffsets: [], _success: false }, + + // Dynamic uniform buffer out of bounds because of binding size + { dynamicOffsets: [512, 0], _success: false }, + { dynamicOffsets: [1024, 0], _success: false }, + { dynamicOffsets: [0xffffffff, 0], _success: false }, + + // Dynamic storage buffer out of bounds because of binding size + { dynamicOffsets: [0, 512], _success: false }, + { dynamicOffsets: [0, 1024], _success: false }, + { dynamicOffsets: [0, 0xffffffff], _success: false }, + ]) + ) + .fn(async t => { + // Dynamic buffer offsets require offset to be divisible by 256 + const MIN_DYNAMIC_BUFFER_OFFSET_ALIGNMENT = 256; + const BINDING_SIZE = 9; + + const bindGroupLayout = t.device.createBindGroupLayout({ + entries: [ + { + binding: 0, + visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, + type: 'uniform-buffer', + hasDynamicOffset: true, + }, + + { + binding: 1, + visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, + type: 'storage-buffer', + hasDynamicOffset: true, + }, + ], + }); + + const uniformBuffer = t.device.createBuffer({ + size: 2 * MIN_DYNAMIC_BUFFER_OFFSET_ALIGNMENT + 8, + usage: GPUBufferUsage.UNIFORM, + }); + + const storageBuffer = t.device.createBuffer({ + size: 2 * MIN_DYNAMIC_BUFFER_OFFSET_ALIGNMENT + 8, + usage: GPUBufferUsage.STORAGE, + }); + + const bindGroup = t.device.createBindGroup({ + layout: bindGroupLayout, + entries: [ + { + binding: 0, + resource: { + buffer: uniformBuffer, + size: BINDING_SIZE, + }, + }, + + { + binding: 1, + resource: { + buffer: storageBuffer, + size: BINDING_SIZE, + }, + }, + ], + }); + + const { type, dynamicOffsets, _success } = t.params; + + t.expectValidationError(() => { + if (type === 'compute') { + t.testComputePass(bindGroup, dynamicOffsets); + } else if (type === 'renderpass') { + t.testRenderPass(bindGroup, dynamicOffsets); + } else if (type === 'renderbundle') { + t.testRenderBundle(bindGroup, dynamicOffsets); + } else { + t.fail(); + } + t.testComputePass(bindGroup, dynamicOffsets); + }, !_success); + }); + +// TODO: test error bind group diff --git a/tests/wpt/webgpu/tests/webgpu/webgpu/api/validation/setBlendColor.spec.js b/tests/wpt/webgpu/tests/webgpu/webgpu/api/validation/setBlendColor.spec.js new file mode 100644 index 00000000000..8a302fffd98 --- /dev/null +++ b/tests/wpt/webgpu/tests/webgpu/webgpu/api/validation/setBlendColor.spec.js @@ -0,0 +1,49 @@ +/** + * AUTO-GENERATED - DO NOT EDIT. Source: https://github.com/gpuweb/cts + **/ export const description = ` +setBlendColor validation tests. +`; +import { makeTestGroup } from '../../../common/framework/test_group.js'; + +import { ValidationTest } from './validation_test.js'; + +// TODO: Move beginRenderPass to a Fixture class. +class F extends ValidationTest { + beginRenderPass(commandEncoder) { + const attachmentTexture = this.device.createTexture({ + format: 'rgba8unorm', + size: { width: 16, height: 16, depth: 1 }, + usage: GPUTextureUsage.OUTPUT_ATTACHMENT, + }); + + return commandEncoder.beginRenderPass({ + colorAttachments: [ + { + attachment: attachmentTexture.createView(), + loadValue: { r: 1.0, g: 0.0, b: 0.0, a: 1.0 }, + }, + ], + }); + } +} + +export const g = makeTestGroup(F); + +g.test('basic_use_of_setBlendColor').fn(t => { + const commandEncoder = t.device.createCommandEncoder(); + const renderPass = t.beginRenderPass(commandEncoder); + renderPass.setBlendColor({ r: 0, g: 0, b: 0, a: 0 }); + renderPass.endPass(); + commandEncoder.finish(); +}); + +g.test('setBlendColor_allows_any_number_value').fn(t => { + const values = [Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER]; + for (const value of values) { + const commandEncoder = t.device.createCommandEncoder(); + const renderPass = t.beginRenderPass(commandEncoder); + renderPass.setBlendColor({ r: value, g: value, b: value, a: value }); + renderPass.endPass(); + commandEncoder.finish(); + } +}); diff --git a/tests/wpt/webgpu/tests/webgpu/webgpu/api/validation/setScissorRect.spec.js b/tests/wpt/webgpu/tests/webgpu/webgpu/api/validation/setScissorRect.spec.js new file mode 100644 index 00000000000..7934c007286 --- /dev/null +++ b/tests/wpt/webgpu/tests/webgpu/webgpu/api/validation/setScissorRect.spec.js @@ -0,0 +1,54 @@ +/** + * AUTO-GENERATED - DO NOT EDIT. Source: https://github.com/gpuweb/cts + **/ export const description = ` +setScissorRect validation tests. +`; +import { makeTestGroup } from '../../../common/framework/test_group.js'; + +import { ValidationTest } from './validation_test.js'; + +const TEXTURE_WIDTH = 16; +const TEXTURE_HEIGHT = 16; + +// TODO: Move this fixture class to a common file. +class F extends ValidationTest { + beginRenderPass(commandEncoder) { + const attachmentTexture = this.device.createTexture({ + format: 'rgba8unorm', + size: { width: TEXTURE_WIDTH, height: TEXTURE_HEIGHT, depth: 1 }, + usage: GPUTextureUsage.OUTPUT_ATTACHMENT, + }); + + return commandEncoder.beginRenderPass({ + colorAttachments: [ + { + attachment: attachmentTexture.createView(), + loadValue: { r: 1.0, g: 0.0, b: 0.0, a: 1.0 }, + }, + ], + }); + } +} + +export const g = makeTestGroup(F); + +g.test('use_of_setScissorRect') + .params([ + { x: 0, y: 0, width: 1, height: 1, _success: true }, // Basic use + { x: 0, y: 0, width: 0, height: 1, _success: false }, // Width of zero is not allowed + { x: 0, y: 0, width: 1, height: 0, _success: false }, // Height of zero is not allowed + { x: 0, y: 0, width: 0, height: 0, _success: false }, // Both width and height of zero are not allowed + { x: 0, y: 0, width: TEXTURE_WIDTH + 1, height: TEXTURE_HEIGHT + 1, _success: true }, // Scissor larger than the framebuffer is allowed + ]) + .fn(async t => { + const { x, y, width, height, _success } = t.params; + + const commandEncoder = t.device.createCommandEncoder(); + const renderPass = t.beginRenderPass(commandEncoder); + renderPass.setScissorRect(x, y, width, height); + renderPass.endPass(); + + t.expectValidationError(() => { + commandEncoder.finish(); + }, !_success); + }); diff --git a/tests/wpt/webgpu/tests/webgpu/webgpu/api/validation/setStencilReference.spec.js b/tests/wpt/webgpu/tests/webgpu/webgpu/api/validation/setStencilReference.spec.js new file mode 100644 index 00000000000..f79a2404495 --- /dev/null +++ b/tests/wpt/webgpu/tests/webgpu/webgpu/api/validation/setStencilReference.spec.js @@ -0,0 +1,43 @@ +/** + * AUTO-GENERATED - DO NOT EDIT. Source: https://github.com/gpuweb/cts + **/ export const description = ` +setStencilReference validation tests. +`; +import { poptions } from '../../../common/framework/params_builder.js'; +import { makeTestGroup } from '../../../common/framework/test_group.js'; + +import { ValidationTest } from './validation_test.js'; + +// TODO: Move this fixture class to a common file. +class F extends ValidationTest { + beginRenderPass(commandEncoder) { + const attachmentTexture = this.device.createTexture({ + format: 'rgba8unorm', + size: { width: 16, height: 16, depth: 1 }, + usage: GPUTextureUsage.OUTPUT_ATTACHMENT, + }); + + return commandEncoder.beginRenderPass({ + colorAttachments: [ + { + attachment: attachmentTexture.createView(), + loadValue: { r: 1.0, g: 0.0, b: 0.0, a: 1.0 }, + }, + ], + }); + } +} + +export const g = makeTestGroup(F); + +g.test('use_of_setStencilReference') + .params(poptions('reference', [0, 0xffffffff])) + .fn(t => { + const { reference } = t.params; + + const commandEncoder = t.device.createCommandEncoder(); + const renderPass = t.beginRenderPass(commandEncoder); + renderPass.setStencilReference(reference); + renderPass.endPass(); + commandEncoder.finish(); + }); diff --git a/tests/wpt/webgpu/tests/webgpu/webgpu/api/validation/setVertexBuffer.spec.js b/tests/wpt/webgpu/tests/webgpu/webgpu/api/validation/setVertexBuffer.spec.js new file mode 100644 index 00000000000..a7a173991eb --- /dev/null +++ b/tests/wpt/webgpu/tests/webgpu/webgpu/api/validation/setVertexBuffer.spec.js @@ -0,0 +1,179 @@ +/** + * AUTO-GENERATED - DO NOT EDIT. Source: https://github.com/gpuweb/cts + **/ export const description = ` +setVertexBuffer validation tests. +`; +import { makeTestGroup } from '../../../common/framework/test_group.js'; +import { range } from '../../../common/framework/util/util.js'; + +import { ValidationTest } from './validation_test.js'; + +class F extends ValidationTest { + getVertexBuffer() { + return this.device.createBuffer({ + size: 256, + usage: GPUBufferUsage.VERTEX, + }); + } + + createRenderPipeline(bufferCount) { + const descriptor = { + vertexStage: this.getVertexStage(bufferCount), + fragmentStage: this.getFragmentStage(), + layout: this.getPipelineLayout(), + primitiveTopology: 'triangle-list', + colorStates: [{ format: 'rgba8unorm' }], + vertexState: { + vertexBuffers: [ + { + arrayStride: 3 * 4, + attributes: range(bufferCount, i => ({ + format: 'float3', + offset: 0, + shaderLocation: i, + })), + }, + ], + }, + }; + + return this.device.createRenderPipeline(descriptor); + } + + getVertexStage(bufferCount) { + const glsl = ` + #version 450 + ${range(bufferCount, i => `\nlayout(location = ${i}) in vec3 a_position${i};`).join('')} + void main() { + gl_Position = vec4(0.0, 0.0, 0.0, 1.0); + } + `; + return { + module: this.makeShaderModule('vertex', { glsl }), + entryPoint: 'main', + }; + } + + getFragmentStage() { + const glsl = ` + #version 450 + layout(location = 0) out vec4 fragColor; + void main() { + fragColor = vec4(0.0, 1.0, 0.0, 1.0); + } + `; + return { + module: this.makeShaderModule('fragment', { glsl }), + entryPoint: 'main', + }; + } + + getPipelineLayout() { + return this.device.createPipelineLayout({ bindGroupLayouts: [] }); + } + + beginRenderPass(commandEncoder) { + const attachmentTexture = this.device.createTexture({ + format: 'rgba8unorm', + size: { width: 16, height: 16, depth: 1 }, + usage: GPUTextureUsage.OUTPUT_ATTACHMENT, + }); + + return commandEncoder.beginRenderPass({ + colorAttachments: [ + { + attachment: attachmentTexture.createView(), + loadValue: { r: 1.0, g: 0.0, b: 0.0, a: 1.0 }, + }, + ], + }); + } +} + +export const g = makeTestGroup(F); + +g.test('vertex_buffers_inherit_from_previous_pipeline').fn(async t => { + const pipeline1 = t.createRenderPipeline(1); + const pipeline2 = t.createRenderPipeline(2); + + const vertexBuffer1 = t.getVertexBuffer(); + const vertexBuffer2 = t.getVertexBuffer(); + + { + // Check failure when vertex buffer is not set + const commandEncoder = t.device.createCommandEncoder(); + const renderPass = t.beginRenderPass(commandEncoder); + renderPass.setPipeline(pipeline1); + renderPass.draw(3, 1, 0, 0); + renderPass.endPass(); + + t.expectValidationError(() => { + commandEncoder.finish(); + }); + } + { + // Check success when vertex buffer is inherited from previous pipeline + const commandEncoder = t.device.createCommandEncoder(); + const renderPass = t.beginRenderPass(commandEncoder); + renderPass.setPipeline(pipeline2); + renderPass.setVertexBuffer(0, vertexBuffer1); + renderPass.setVertexBuffer(1, vertexBuffer2); + renderPass.draw(3, 1, 0, 0); + renderPass.setPipeline(pipeline1); + renderPass.draw(3, 1, 0, 0); + renderPass.endPass(); + + commandEncoder.finish(); + } +}); + +g.test('vertex_buffers_do_not_inherit_between_render_passes').fn(async t => { + const pipeline1 = t.createRenderPipeline(1); + const pipeline2 = t.createRenderPipeline(2); + + const vertexBuffer1 = t.getVertexBuffer(); + const vertexBuffer2 = t.getVertexBuffer(); + + { + // Check success when vertex buffer is set for each render pass + const commandEncoder = t.device.createCommandEncoder(); + { + const renderPass = t.beginRenderPass(commandEncoder); + renderPass.setPipeline(pipeline2); + renderPass.setVertexBuffer(0, vertexBuffer1); + renderPass.setVertexBuffer(1, vertexBuffer2); + renderPass.draw(3, 1, 0, 0); + renderPass.endPass(); + } + { + const renderPass = t.beginRenderPass(commandEncoder); + renderPass.setPipeline(pipeline1); + renderPass.setVertexBuffer(0, vertexBuffer1); + renderPass.draw(3, 1, 0, 0); + renderPass.endPass(); + } + commandEncoder.finish(); + } + { + // Check failure because vertex buffer is not inherited in second subpass + const commandEncoder = t.device.createCommandEncoder(); + { + const renderPass = t.beginRenderPass(commandEncoder); + renderPass.setPipeline(pipeline2); + renderPass.setVertexBuffer(0, vertexBuffer1); + renderPass.setVertexBuffer(1, vertexBuffer2); + renderPass.draw(3, 1, 0, 0); + renderPass.endPass(); + } + { + const renderPass = t.beginRenderPass(commandEncoder); + renderPass.setPipeline(pipeline1); + renderPass.draw(3, 1, 0, 0); + renderPass.endPass(); + } + + t.expectValidationError(() => { + commandEncoder.finish(); + }); + } +}); diff --git a/tests/wpt/webgpu/tests/webgpu/webgpu/api/validation/setViewport.spec.js b/tests/wpt/webgpu/tests/webgpu/webgpu/api/validation/setViewport.spec.js new file mode 100644 index 00000000000..e2ef691b821 --- /dev/null +++ b/tests/wpt/webgpu/tests/webgpu/webgpu/api/validation/setViewport.spec.js @@ -0,0 +1,73 @@ +/** + * AUTO-GENERATED - DO NOT EDIT. Source: https://github.com/gpuweb/cts + **/ export const description = ` +setViewport validation tests. +`; +import { makeTestGroup } from '../../../common/framework/test_group.js'; + +import { ValidationTest } from './validation_test.js'; + +const TEXTURE_WIDTH = 16; +const TEXTURE_HEIGHT = 16; + +// TODO: Move this fixture class to a common file. +class F extends ValidationTest { + beginRenderPass(commandEncoder) { + const attachmentTexture = this.device.createTexture({ + format: 'rgba8unorm', + size: { width: TEXTURE_WIDTH, height: TEXTURE_HEIGHT, depth: 1 }, + usage: GPUTextureUsage.OUTPUT_ATTACHMENT, + }); + + return commandEncoder.beginRenderPass({ + colorAttachments: [ + { + attachment: attachmentTexture.createView(), + loadValue: { r: 1.0, g: 0.0, b: 0.0, a: 1.0 }, + }, + ], + }); + } +} + +export const g = makeTestGroup(F); + +g.test('use_of_setViewport') + .params([ + { x: 0, y: 0, width: 1, height: 1, minDepth: 0, maxDepth: 1, _success: true }, // Basic use + { x: 0, y: 0, width: 0, height: 1, minDepth: 0, maxDepth: 1, _success: false }, // Width of zero is not allowed + { x: 0, y: 0, width: 1, height: 0, minDepth: 0, maxDepth: 1, _success: false }, // Height of zero is not allowed + { x: 0, y: 0, width: 0, height: 0, minDepth: 0, maxDepth: 1, _success: false }, // Both width and height of zero are not allowed + { x: -1, y: 0, width: 1, height: 1, minDepth: 0, maxDepth: 1, _success: true }, // Negative x is allowed + { x: 0, y: -1, width: 1, height: 1, minDepth: 0, maxDepth: 1, _success: true }, // Negative y is allowed + { x: 0, y: 0, width: -1, height: 1, minDepth: 0, maxDepth: 1, _success: false }, // Negative width is not allowed + { x: 0, y: 0, width: 1, height: -1, minDepth: 0, maxDepth: 1, _success: false }, // Negative height is not allowed + { x: 0, y: 0, width: 1, height: 1, minDepth: -1, maxDepth: 1, _success: false }, // Negative minDepth is not allowed + { x: 0, y: 0, width: 1, height: 1, minDepth: 0, maxDepth: -1, _success: false }, // Negative maxDepth is not allowed + { x: 0, y: 0, width: 1, height: 1, minDepth: 10, maxDepth: 1, _success: false }, // minDepth greater than 1 is not allowed + { x: 0, y: 0, width: 1, height: 1, minDepth: 0, maxDepth: 10, _success: false }, // maxDepth greater than 1 is not allowed + { x: 0, y: 0, width: 1, height: 1, minDepth: 0.5, maxDepth: 0.5, _success: true }, // minDepth equal to maxDepth is allowed + { x: 0, y: 0, width: 1, height: 1, minDepth: 0.8, maxDepth: 0.5, _success: true }, // minDepth greater than maxDepth is allowed + { + x: 0, + y: 0, + width: TEXTURE_WIDTH + 1, + height: TEXTURE_HEIGHT + 1, + minDepth: 0, + maxDepth: 1, + _success: true, + }, + // Viewport larger than the framebuffer is allowed + ]) + .fn(async t => { + const { x, y, width, height, minDepth, maxDepth, _success } = t.params; + + const commandEncoder = t.device.createCommandEncoder(); + const renderPass = t.beginRenderPass(commandEncoder); + renderPass.setViewport(x, y, width, height, minDepth, maxDepth); + renderPass.endPass(); + + t.expectValidationError(() => { + commandEncoder.finish(); + }, !_success); + }); diff --git a/tests/wpt/webgpu/tests/webgpu/webgpu/api/validation/validation_test.js b/tests/wpt/webgpu/tests/webgpu/webgpu/api/validation/validation_test.js new file mode 100644 index 00000000000..d816fd0594b --- /dev/null +++ b/tests/wpt/webgpu/tests/webgpu/webgpu/api/validation/validation_test.js @@ -0,0 +1,116 @@ +/** + * AUTO-GENERATED - DO NOT EDIT. Source: https://github.com/gpuweb/cts + **/ import { unreachable } from '../../../common/framework/util/util.js'; +import { GPUTest } from '../../gpu_test.js'; + +export class ValidationTest extends GPUTest { + getStorageBuffer() { + return this.device.createBuffer({ size: 1024, usage: GPUBufferUsage.STORAGE }); + } + + getUniformBuffer() { + return this.device.createBuffer({ size: 1024, usage: GPUBufferUsage.UNIFORM }); + } + + getErrorBuffer() { + this.device.pushErrorScope('validation'); + const errorBuffer = this.device.createBuffer({ + size: 1024, + usage: 0xffff, // Invalid GPUBufferUsage + }); + this.device.popErrorScope(); + return errorBuffer; + } + + getSampler() { + return this.device.createSampler(); + } + + getComparisonSampler() { + return this.device.createSampler({ compare: 'never' }); + } + + getErrorSampler() { + this.device.pushErrorScope('validation'); + const sampler = this.device.createSampler({ lodMinClamp: -1 }); + this.device.popErrorScope(); + return sampler; + } + + getSampledTexture() { + return this.device.createTexture({ + size: { width: 16, height: 16, depth: 1 }, + format: 'rgba8unorm', + usage: GPUTextureUsage.SAMPLED, + }); + } + + getStorageTexture() { + return this.device.createTexture({ + size: { width: 16, height: 16, depth: 1 }, + format: 'rgba8unorm', + usage: GPUTextureUsage.STORAGE, + }); + } + + getErrorTextureView() { + this.device.pushErrorScope('validation'); + const view = this.device + .createTexture({ + size: { width: 0, height: 0, depth: 0 }, + format: 'rgba8unorm', + usage: GPUTextureUsage.SAMPLED, + }) + .createView(); + this.device.popErrorScope(); + return view; + } + + getBindingResource(bindingType) { + switch (bindingType) { + case 'errorBuf': + return { buffer: this.getErrorBuffer() }; + case 'errorSamp': + return this.getErrorSampler(); + case 'errorTex': + return this.getErrorTextureView(); + case 'uniformBuf': + return { buffer: this.getUniformBuffer() }; + case 'storageBuf': + return { buffer: this.getStorageBuffer() }; + case 'plainSamp': + return this.getSampler(); + case 'compareSamp': + return this.getComparisonSampler(); + case 'sampledTex': + return this.getSampledTexture().createView(); + case 'storageTex': + return this.getStorageTexture().createView(); + default: + unreachable('unknown binding resource type'); + } + } + + expectValidationError(fn, shouldError = true) { + // If no error is expected, we let the scope surrounding the test catch it. + if (shouldError === false) { + fn(); + return; + } + + this.device.pushErrorScope('validation'); + fn(); + const promise = this.device.popErrorScope(); + + this.eventualAsyncExpectation(async niceStack => { + const gpuValidationError = await promise; + if (!gpuValidationError) { + niceStack.message = 'Validation error was expected.'; + this.rec.validationFailed(niceStack); + } else if (gpuValidationError instanceof GPUValidationError) { + niceStack.message = `Captured validation error - ${gpuValidationError.message}`; + this.rec.debug(niceStack); + } + }); + } +} diff --git a/tests/wpt/webgpu/tests/webgpu/webgpu/api/validation/vertex_state.spec.js b/tests/wpt/webgpu/tests/webgpu/webgpu/api/validation/vertex_state.spec.js new file mode 100644 index 00000000000..7a30e3a013a --- /dev/null +++ b/tests/wpt/webgpu/tests/webgpu/webgpu/api/validation/vertex_state.spec.js @@ -0,0 +1,722 @@ +/** + * AUTO-GENERATED - DO NOT EDIT. Source: https://github.com/gpuweb/cts + **/ export const description = ` +vertexState validation tests. +`; +import { makeTestGroup } from '../../../common/framework/test_group.js'; + +import { ValidationTest } from './validation_test.js'; + +const MAX_VERTEX_ATTRIBUTES = 16; +const MAX_VERTEX_BUFFER_END = 2048; +const MAX_VERTEX_BUFFER_ARRAY_STRIDE = 2048; +const MAX_VERTEX_BUFFERS = 16; + +const SIZEOF_FLOAT = Float32Array.BYTES_PER_ELEMENT; + +const VERTEX_SHADER_CODE_WITH_NO_INPUT = ` + #version 450 + void main() { + gl_Position = vec4(0.0); + } +`; + +const FRAGMENT_SHADER_CODE = ` + #version 450 + layout(location = 0) out vec4 fragColor; + void main() { + fragColor = vec4(0.0, 1.0, 0.0, 1.0); + } +`; + +function clone(descriptor) { + return JSON.parse(JSON.stringify(descriptor)); +} + +class F extends ValidationTest { + getDescriptor(vertexState, vertexShaderCode) { + const descriptor = { + vertexStage: { + module: this.makeShaderModule('vertex', { glsl: vertexShaderCode }), + entryPoint: 'main', + }, + + fragmentStage: { + module: this.makeShaderModule('fragment', { glsl: FRAGMENT_SHADER_CODE }), + entryPoint: 'main', + }, + + layout: this.device.createPipelineLayout({ bindGroupLayouts: [] }), + primitiveTopology: 'triangle-list', + colorStates: [{ format: 'rgba8unorm' }], + vertexState, + }; + + return descriptor; + } +} + +export const g = makeTestGroup(F); + +g.test('an_empty_vertex_input_is_valid').fn(t => { + const vertexState = {}; + const descriptor = t.getDescriptor(vertexState, VERTEX_SHADER_CODE_WITH_NO_INPUT); + t.device.createRenderPipeline(descriptor); +}); + +g.test('a_null_buffer_is_valid').fn(t => { + { + // One null buffer is OK + const vertexState = { + vertexBuffers: [ + { + arrayStride: 0, + attributes: [], + }, + ], + }; + + const descriptor = t.getDescriptor(vertexState, VERTEX_SHADER_CODE_WITH_NO_INPUT); + t.device.createRenderPipeline(descriptor); + } + { + // One null buffer followed by a buffer is OK + const vertexState = { + vertexBuffers: [ + { + arrayStride: 0, + attributes: [], + }, + + { + arrayStride: 0, + attributes: [ + { + format: 'float', + offset: 0, + shaderLocation: 0, + }, + ], + }, + ], + }; + + const descriptor = t.getDescriptor(vertexState, VERTEX_SHADER_CODE_WITH_NO_INPUT); + t.device.createRenderPipeline(descriptor); + } + { + // One null buffer sitting between buffers is OK + const vertexState = { + vertexBuffers: [ + { + arrayStride: 0, + attributes: [ + { + format: 'float', + offset: 0, + shaderLocation: 0, + }, + ], + }, + + { + arrayStride: 0, + attributes: [], + }, + + { + arrayStride: 0, + attributes: [ + { + format: 'float', + offset: 0, + shaderLocation: 1, + }, + ], + }, + ], + }; + + const descriptor = t.getDescriptor(vertexState, VERTEX_SHADER_CODE_WITH_NO_INPUT); + t.device.createRenderPipeline(descriptor); + } +}); + +g.test('pipeline_vertex_buffers_are_backed_by_attributes_in_vertex_input').fn(async t => { + const vertexState = { + vertexBuffers: [ + { + arrayStride: 2 * SIZEOF_FLOAT, + attributes: [ + { + format: 'float', + offset: 0, + shaderLocation: 0, + }, + + { + format: 'float', + offset: 0, + shaderLocation: 1, + }, + ], + }, + ], + }; + + { + // Control case: pipeline with one input per attribute + const code = ` + #version 450 + layout(location = 0) in vec4 a; + layout(location = 1) in vec4 b; + void main() { + gl_Position = vec4(0.0); + } + `; + const descriptor = t.getDescriptor(vertexState, code); + t.device.createRenderPipeline(descriptor); + } + { + // Check it is valid for the pipeline to use a subset of the VertexState + const code = ` + #version 450 + layout(location = 0) in vec4 a; + void main() { + gl_Position = vec4(0.0); + } + `; + const descriptor = t.getDescriptor(vertexState, code); + t.device.createRenderPipeline(descriptor); + } + { + // Check for an error when the pipeline uses an attribute not in the vertex input + const code = ` + #version 450 + layout(location = 2) in vec4 a; + void main() { + gl_Position = vec4(0.0); + } + `; + const descriptor = t.getDescriptor(vertexState, code); + + t.expectValidationError(() => { + t.device.createRenderPipeline(descriptor); + }); + } +}); + +g.test('an_arrayStride_of_0_is_valid').fn(t => { + const vertexState = { + vertexBuffers: [ + { + arrayStride: 0, + attributes: [ + { + format: 'float', + offset: 0, + shaderLocation: 0, + }, + ], + }, + ], + }; + + { + // Works ok without attributes + const descriptor = t.getDescriptor(vertexState, VERTEX_SHADER_CODE_WITH_NO_INPUT); + t.device.createRenderPipeline(descriptor); + } + { + // Works ok with attributes at a large-ish offset + vertexState.vertexBuffers[0].attributes[0].offset = 128; + const descriptor = t.getDescriptor(vertexState, VERTEX_SHADER_CODE_WITH_NO_INPUT); + t.device.createRenderPipeline(descriptor); + } +}); + +g.test('offset_should_be_within_vertex_buffer_arrayStride_if_arrayStride_is_not_zero').fn( + async t => { + const vertexState = { + vertexBuffers: [ + { + arrayStride: 2 * SIZEOF_FLOAT, + attributes: [ + { + format: 'float', + offset: 0, + shaderLocation: 0, + }, + + { + format: 'float', + offset: SIZEOF_FLOAT, + shaderLocation: 1, + }, + ], + }, + ], + }; + + { + // Control case, setting correct arrayStride and offset + const descriptor = t.getDescriptor(vertexState, VERTEX_SHADER_CODE_WITH_NO_INPUT); + t.device.createRenderPipeline(descriptor); + } + { + // Test vertex attribute offset exceed vertex buffer arrayStride range + const badVertexState = clone(vertexState); + badVertexState.vertexBuffers[0].attributes[1].format = 'float2'; + const descriptor = t.getDescriptor(badVertexState, VERTEX_SHADER_CODE_WITH_NO_INPUT); + + t.expectValidationError(() => { + t.device.createRenderPipeline(descriptor); + }); + } + { + // Test vertex attribute offset exceed vertex buffer arrayStride range + const badVertexState = clone(vertexState); + badVertexState.vertexBuffers[0].arrayStride = SIZEOF_FLOAT; + const descriptor = t.getDescriptor(badVertexState, VERTEX_SHADER_CODE_WITH_NO_INPUT); + + t.expectValidationError(() => { + t.device.createRenderPipeline(descriptor); + }); + } + { + // It's OK if arrayStride is zero + const goodVertexState = clone(vertexState); + goodVertexState.vertexBuffers[0].arrayStride = 0; + const descriptor = t.getDescriptor(goodVertexState, VERTEX_SHADER_CODE_WITH_NO_INPUT); + t.device.createRenderPipeline(descriptor); + } + } +); + +// TODO: This should be made into an operation test. +g.test('check_two_attributes_overlapping').fn(async t => { + const vertexState = { + vertexBuffers: [ + { + arrayStride: 2 * SIZEOF_FLOAT, + attributes: [ + { + format: 'float', + offset: 0, + shaderLocation: 0, + }, + + { + format: 'float', + offset: SIZEOF_FLOAT, + shaderLocation: 1, + }, + ], + }, + ], + }; + + { + // Control case, setting correct arrayStride and offset + const descriptor = t.getDescriptor(vertexState, VERTEX_SHADER_CODE_WITH_NO_INPUT); + t.device.createRenderPipeline(descriptor); + } + { + // Test two attributes overlapping + const overlappingVertexState = clone(vertexState); + overlappingVertexState.vertexBuffers[0].attributes[0].format = 'int2'; + const descriptor = t.getDescriptor(overlappingVertexState, VERTEX_SHADER_CODE_WITH_NO_INPUT); + t.device.createRenderPipeline(descriptor); + } +}); + +g.test('check_out_of_bounds_condition_on_total_number_of_vertex_buffers').fn(async t => { + const vertexBuffers = []; + + for (let i = 0; i < MAX_VERTEX_BUFFERS; i++) { + vertexBuffers.push({ + arrayStride: 0, + attributes: [ + { + format: 'float', + offset: 0, + shaderLocation: i, + }, + ], + }); + } + { + // Control case, setting max vertex buffer number + const vertexState = { vertexBuffers }; + const descriptor = t.getDescriptor(vertexState, VERTEX_SHADER_CODE_WITH_NO_INPUT); + t.device.createRenderPipeline(descriptor); + } + { + // Test vertex buffer number exceed the limit + const vertexState = { + vertexBuffers: [ + ...vertexBuffers, + { + arrayStride: 0, + attributes: [ + { + format: 'float', + offset: 0, + shaderLocation: MAX_VERTEX_BUFFERS, + }, + ], + }, + ], + }; + + const descriptor = t.getDescriptor(vertexState, VERTEX_SHADER_CODE_WITH_NO_INPUT); + + t.expectValidationError(() => { + t.device.createRenderPipeline(descriptor); + }); + } +}); + +g.test('check_out_of_bounds_on_number_of_vertex_attributes_on_a_single_vertex_buffer').fn( + async t => { + const vertexAttributes = []; + + for (let i = 0; i < MAX_VERTEX_ATTRIBUTES; i++) { + vertexAttributes.push({ + format: 'float', + offset: 0, + shaderLocation: i, + }); + } + { + // Control case, setting max vertex buffer number + const vertexState = { + vertexBuffers: [ + { + arrayStride: 0, + attributes: vertexAttributes, + }, + ], + }; + + const descriptor = t.getDescriptor(vertexState, VERTEX_SHADER_CODE_WITH_NO_INPUT); + t.device.createRenderPipeline(descriptor); + } + { + // Test vertex attribute number exceed the limit + const vertexState = { + vertexBuffers: [ + { + arrayStride: 0, + attributes: [ + ...vertexAttributes, + { + format: 'float', + offset: 0, + shaderLocation: MAX_VERTEX_ATTRIBUTES, + }, + ], + }, + ], + }; + + const descriptor = t.getDescriptor(vertexState, VERTEX_SHADER_CODE_WITH_NO_INPUT); + + t.expectValidationError(() => { + t.device.createRenderPipeline(descriptor); + }); + } + } +); + +g.test('check_out_of_bounds_on_number_of_vertex_attributes_across_vertex_buffers').fn(async t => { + const vertexBuffers = []; + for (let i = 0; i < MAX_VERTEX_ATTRIBUTES; i++) { + vertexBuffers.push({ + arrayStride: 0, + attributes: [{ format: 'float', offset: 0, shaderLocation: i }], + }); + } + + { + // Control case, setting max vertex buffer number + const vertexState = { vertexBuffers }; + const descriptor = t.getDescriptor(vertexState, VERTEX_SHADER_CODE_WITH_NO_INPUT); + t.device.createRenderPipeline(descriptor); + } + { + // Test vertex attribute number exceed the limit + vertexBuffers[MAX_VERTEX_ATTRIBUTES - 1].attributes.push({ + format: 'float', + offset: 0, + shaderLocation: MAX_VERTEX_ATTRIBUTES, + }); + + const vertexState = { vertexBuffers }; + const descriptor = t.getDescriptor(vertexState, VERTEX_SHADER_CODE_WITH_NO_INPUT); + + t.expectValidationError(() => { + t.device.createRenderPipeline(descriptor); + }); + } +}); + +g.test('check_out_of_bounds_condition_on_input_strides').fn(async t => { + const vertexState = { + vertexBuffers: [{ arrayStride: MAX_VERTEX_BUFFER_ARRAY_STRIDE, attributes: [] }], + }; + + { + // Control case, setting max input arrayStride + const descriptor = t.getDescriptor(vertexState, VERTEX_SHADER_CODE_WITH_NO_INPUT); + t.device.createRenderPipeline(descriptor); + } + { + // Test input arrayStride OOB + vertexState.vertexBuffers[0].arrayStride = MAX_VERTEX_BUFFER_ARRAY_STRIDE + 4; + const descriptor = t.getDescriptor(vertexState, VERTEX_SHADER_CODE_WITH_NO_INPUT); + + t.expectValidationError(() => { + t.device.createRenderPipeline(descriptor); + }); + } +}); + +g.test('check_multiple_of_4_bytes_constraint_on_input_arrayStride').fn(async t => { + const vertexState = { + vertexBuffers: [ + { + arrayStride: 4, + attributes: [{ format: 'uchar2', offset: 0, shaderLocation: 0 }], + }, + ], + }; + + { + // Control case, setting input arrayStride 4 bytes + const descriptor = t.getDescriptor(vertexState, VERTEX_SHADER_CODE_WITH_NO_INPUT); + t.device.createRenderPipeline(descriptor); + } + { + // Test input arrayStride not multiple of 4 bytes + vertexState.vertexBuffers[0].arrayStride = 2; + const descriptor = t.getDescriptor(vertexState, VERTEX_SHADER_CODE_WITH_NO_INPUT); + + t.expectValidationError(() => { + t.device.createRenderPipeline(descriptor); + }); + } +}); + +g.test('identical_duplicate_attributes_are_invalid').fn(async t => { + const vertexState = { + vertexBuffers: [ + { + arrayStride: 0, + attributes: [{ format: 'float', offset: 0, shaderLocation: 0 }], + }, + ], + }; + + { + // Control case, setting attribute 0 + const descriptor = t.getDescriptor(vertexState, VERTEX_SHADER_CODE_WITH_NO_INPUT); + t.device.createRenderPipeline(descriptor); + } + { + // Oh no, attribute 0 is set twice + vertexState.vertexBuffers[0].attributes.push({ + format: 'float', + offset: 0, + shaderLocation: 0, + }); + + const descriptor = t.getDescriptor(vertexState, VERTEX_SHADER_CODE_WITH_NO_INPUT); + + t.expectValidationError(() => { + t.device.createRenderPipeline(descriptor); + }); + } +}); + +g.test('we_cannot_set_same_shader_location').fn(async t => { + { + const vertexState = { + vertexBuffers: [ + { + arrayStride: 0, + attributes: [ + { format: 'float', offset: 0, shaderLocation: 0 }, + { format: 'float', offset: SIZEOF_FLOAT, shaderLocation: 1 }, + ], + }, + ], + }; + + { + // Control case, setting different shader locations in two attributes + const descriptor = t.getDescriptor(vertexState, VERTEX_SHADER_CODE_WITH_NO_INPUT); + t.device.createRenderPipeline(descriptor); + } + { + // Test same shader location in two attributes in the same buffer + vertexState.vertexBuffers[0].attributes[1].shaderLocation = 0; + const descriptor = t.getDescriptor(vertexState, VERTEX_SHADER_CODE_WITH_NO_INPUT); + + t.expectValidationError(() => { + t.device.createRenderPipeline(descriptor); + }); + } + } + { + const vertexState = { + vertexBuffers: [ + { + arrayStride: 0, + attributes: [ + { + format: 'float', + offset: 0, + shaderLocation: 0, + }, + ], + }, + + { + arrayStride: 0, + attributes: [ + { + format: 'float', + offset: 0, + shaderLocation: 0, + }, + ], + }, + ], + }; + + // Test same shader location in two attributes in different buffers + const descriptor = t.getDescriptor(vertexState, VERTEX_SHADER_CODE_WITH_NO_INPUT); + + t.expectValidationError(() => { + t.device.createRenderPipeline(descriptor); + }); + } +}); + +g.test('check_out_of_bounds_condition_on_attribute_shader_location').fn(async t => { + const vertexState = { + vertexBuffers: [ + { + arrayStride: 0, + attributes: [{ format: 'float', offset: 0, shaderLocation: MAX_VERTEX_ATTRIBUTES - 1 }], + }, + ], + }; + + { + // Control case, setting last attribute shader location + const descriptor = t.getDescriptor(vertexState, VERTEX_SHADER_CODE_WITH_NO_INPUT); + t.device.createRenderPipeline(descriptor); + } + { + // Test attribute location OOB + vertexState.vertexBuffers[0].attributes[0].shaderLocation = MAX_VERTEX_ATTRIBUTES; + const descriptor = t.getDescriptor(vertexState, VERTEX_SHADER_CODE_WITH_NO_INPUT); + + t.expectValidationError(() => { + t.device.createRenderPipeline(descriptor); + }); + } +}); + +g.test('check_attribute_offset_out_of_bounds').fn(async t => { + const vertexState = { + vertexBuffers: [ + { + arrayStride: 0, + attributes: [ + { + format: 'float2', + offset: MAX_VERTEX_BUFFER_END - 2 * SIZEOF_FLOAT, + shaderLocation: 0, + }, + ], + }, + ], + }; + + { + // Control case, setting max attribute offset to MAX_VERTEX_BUFFER_END - 8 + const descriptor = t.getDescriptor(vertexState, VERTEX_SHADER_CODE_WITH_NO_INPUT); + t.device.createRenderPipeline(descriptor); + } + { + // Control case, setting attribute offset to 8 + vertexState.vertexBuffers[0].attributes[0].offset = 8; + const descriptor = t.getDescriptor(vertexState, VERTEX_SHADER_CODE_WITH_NO_INPUT); + t.device.createRenderPipeline(descriptor); + } + { + // Test attribute offset out of bounds + vertexState.vertexBuffers[0].attributes[0].offset = MAX_VERTEX_BUFFER_END - 4; + const descriptor = t.getDescriptor(vertexState, VERTEX_SHADER_CODE_WITH_NO_INPUT); + + t.expectValidationError(() => { + t.device.createRenderPipeline(descriptor); + }); + } +}); + +g.test('check_multiple_of_4_bytes_constraint_on_offset').fn(async t => { + const vertexState = { + vertexBuffers: [ + { + arrayStride: 0, + attributes: [{ format: 'float', offset: SIZEOF_FLOAT, shaderLocation: 0 }], + }, + ], + }; + + { + // Control case, setting offset 4 bytes + const descriptor = t.getDescriptor(vertexState, VERTEX_SHADER_CODE_WITH_NO_INPUT); + t.device.createRenderPipeline(descriptor); + } + { + // Test offset of 2 bytes with uchar2 format + vertexState.vertexBuffers[0].attributes[0].offset = 2; + vertexState.vertexBuffers[0].attributes[0].format = 'uchar2'; + const descriptor = t.getDescriptor(vertexState, VERTEX_SHADER_CODE_WITH_NO_INPUT); + t.expectValidationError(() => { + t.device.createRenderPipeline(descriptor); + }); + } + { + // Test offset of 2 bytes with float format + vertexState.vertexBuffers[0].attributes[0].offset = 2; + vertexState.vertexBuffers[0].attributes[0].format = 'float'; + const descriptor = t.getDescriptor(vertexState, VERTEX_SHADER_CODE_WITH_NO_INPUT); + + t.expectValidationError(() => { + t.device.createRenderPipeline(descriptor); + }); + } +}); + +g.test('check_attribute_offset_overflow').fn(async t => { + const vertexState = { + vertexBuffers: [ + { + arrayStride: 0, + attributes: [{ format: 'float', offset: Number.MAX_SAFE_INTEGER, shaderLocation: 0 }], + }, + ], + }; + + const descriptor = t.getDescriptor(vertexState, VERTEX_SHADER_CODE_WITH_NO_INPUT); + + t.expectValidationError(() => { + t.device.createRenderPipeline(descriptor); + }); +}); diff --git a/tests/wpt/webgpu/tests/webgpu/webgpu/capability_info.js b/tests/wpt/webgpu/tests/webgpu/webgpu/capability_info.js new file mode 100644 index 00000000000..df73575693b --- /dev/null +++ b/tests/wpt/webgpu/tests/webgpu/webgpu/capability_info.js @@ -0,0 +1,629 @@ +/** + * AUTO-GENERATED - DO NOT EDIT. Source: https://github.com/gpuweb/cts + **/ + +function keysOf(obj) { + return Object.keys(obj); +} + +function numericKeysOf(obj) { + return Object.keys(obj).map(n => Number(n)); +} + +// Textures + +export const kTextureFormatInfo = { + // Try to keep these manually-formatted in a readable grid. + // (Note: this list should always match the one in the spec.) + + // 8-bit formats + r8unorm: { + renderable: true, + color: true, + depth: false, + stencil: false, + storage: false, + copyable: true, + bytesPerBlock: 1, + blockWidth: 1, + blockHeight: 1, + }, + r8snorm: { + renderable: false, + color: true, + depth: false, + stencil: false, + storage: false, + copyable: true, + bytesPerBlock: 1, + blockWidth: 1, + blockHeight: 1, + }, + r8uint: { + renderable: true, + color: true, + depth: false, + stencil: false, + storage: false, + copyable: true, + bytesPerBlock: 1, + blockWidth: 1, + blockHeight: 1, + }, + r8sint: { + renderable: true, + color: true, + depth: false, + stencil: false, + storage: false, + copyable: true, + bytesPerBlock: 1, + blockWidth: 1, + blockHeight: 1, + }, + // 16-bit formats + r16uint: { + renderable: true, + color: true, + depth: false, + stencil: false, + storage: false, + copyable: true, + bytesPerBlock: 2, + blockWidth: 1, + blockHeight: 1, + }, + r16sint: { + renderable: true, + color: true, + depth: false, + stencil: false, + storage: false, + copyable: true, + bytesPerBlock: 2, + blockWidth: 1, + blockHeight: 1, + }, + r16float: { + renderable: true, + color: true, + depth: false, + stencil: false, + storage: false, + copyable: true, + bytesPerBlock: 2, + blockWidth: 1, + blockHeight: 1, + }, + rg8unorm: { + renderable: true, + color: true, + depth: false, + stencil: false, + storage: false, + copyable: true, + bytesPerBlock: 2, + blockWidth: 1, + blockHeight: 1, + }, + rg8snorm: { + renderable: false, + color: true, + depth: false, + stencil: false, + storage: false, + copyable: true, + bytesPerBlock: 2, + blockWidth: 1, + blockHeight: 1, + }, + rg8uint: { + renderable: true, + color: true, + depth: false, + stencil: false, + storage: false, + copyable: true, + bytesPerBlock: 2, + blockWidth: 1, + blockHeight: 1, + }, + rg8sint: { + renderable: true, + color: true, + depth: false, + stencil: false, + storage: false, + copyable: true, + bytesPerBlock: 2, + blockWidth: 1, + blockHeight: 1, + }, + // 32-bit formats + r32uint: { + renderable: true, + color: true, + depth: false, + stencil: false, + storage: true, + copyable: true, + bytesPerBlock: 4, + blockWidth: 1, + blockHeight: 1, + }, + r32sint: { + renderable: true, + color: true, + depth: false, + stencil: false, + storage: true, + copyable: true, + bytesPerBlock: 4, + blockWidth: 1, + blockHeight: 1, + }, + r32float: { + renderable: true, + color: true, + depth: false, + stencil: false, + storage: true, + copyable: true, + bytesPerBlock: 4, + blockWidth: 1, + blockHeight: 1, + }, + rg16uint: { + renderable: true, + color: true, + depth: false, + stencil: false, + storage: false, + copyable: true, + bytesPerBlock: 4, + blockWidth: 1, + blockHeight: 1, + }, + rg16sint: { + renderable: true, + color: true, + depth: false, + stencil: false, + storage: false, + copyable: true, + bytesPerBlock: 4, + blockWidth: 1, + blockHeight: 1, + }, + rg16float: { + renderable: true, + color: true, + depth: false, + stencil: false, + storage: false, + copyable: true, + bytesPerBlock: 4, + blockWidth: 1, + blockHeight: 1, + }, + rgba8unorm: { + renderable: true, + color: true, + depth: false, + stencil: false, + storage: true, + copyable: true, + bytesPerBlock: 4, + blockWidth: 1, + blockHeight: 1, + }, + 'rgba8unorm-srgb': { + renderable: true, + color: true, + depth: false, + stencil: false, + storage: false, + copyable: true, + bytesPerBlock: 4, + blockWidth: 1, + blockHeight: 1, + }, + rgba8snorm: { + renderable: false, + color: true, + depth: false, + stencil: false, + storage: true, + copyable: true, + bytesPerBlock: 4, + blockWidth: 1, + blockHeight: 1, + }, + rgba8uint: { + renderable: true, + color: true, + depth: false, + stencil: false, + storage: true, + copyable: true, + bytesPerBlock: 4, + blockWidth: 1, + blockHeight: 1, + }, + rgba8sint: { + renderable: true, + color: true, + depth: false, + stencil: false, + storage: true, + copyable: true, + bytesPerBlock: 4, + blockWidth: 1, + blockHeight: 1, + }, + bgra8unorm: { + renderable: true, + color: true, + depth: false, + stencil: false, + storage: false, + copyable: true, + bytesPerBlock: 4, + blockWidth: 1, + blockHeight: 1, + }, + 'bgra8unorm-srgb': { + renderable: true, + color: true, + depth: false, + stencil: false, + storage: false, + copyable: true, + bytesPerBlock: 4, + blockWidth: 1, + blockHeight: 1, + }, + // Packed 32-bit formats + rgb10a2unorm: { + renderable: true, + color: true, + depth: false, + stencil: false, + storage: false, + copyable: true, + bytesPerBlock: 4, + blockWidth: 1, + blockHeight: 1, + }, + rg11b10float: { + renderable: false, + color: true, + depth: false, + stencil: false, + storage: false, + copyable: true, + bytesPerBlock: 4, + blockWidth: 1, + blockHeight: 1, + }, + // 64-bit formats + rg32uint: { + renderable: true, + color: true, + depth: false, + stencil: false, + storage: true, + copyable: true, + bytesPerBlock: 8, + blockWidth: 1, + blockHeight: 1, + }, + rg32sint: { + renderable: true, + color: true, + depth: false, + stencil: false, + storage: true, + copyable: true, + bytesPerBlock: 8, + blockWidth: 1, + blockHeight: 1, + }, + rg32float: { + renderable: true, + color: true, + depth: false, + stencil: false, + storage: true, + copyable: true, + bytesPerBlock: 8, + blockWidth: 1, + blockHeight: 1, + }, + rgba16uint: { + renderable: true, + color: true, + depth: false, + stencil: false, + storage: true, + copyable: true, + bytesPerBlock: 8, + blockWidth: 1, + blockHeight: 1, + }, + rgba16sint: { + renderable: true, + color: true, + depth: false, + stencil: false, + storage: true, + copyable: true, + bytesPerBlock: 8, + blockWidth: 1, + blockHeight: 1, + }, + rgba16float: { + renderable: true, + color: true, + depth: false, + stencil: false, + storage: true, + copyable: true, + bytesPerBlock: 8, + blockWidth: 1, + blockHeight: 1, + }, + // 128-bit formats + rgba32uint: { + renderable: true, + color: true, + depth: false, + stencil: false, + storage: true, + copyable: true, + bytesPerBlock: 16, + blockWidth: 1, + blockHeight: 1, + }, + rgba32sint: { + renderable: true, + color: true, + depth: false, + stencil: false, + storage: true, + copyable: true, + bytesPerBlock: 16, + blockWidth: 1, + blockHeight: 1, + }, + rgba32float: { + renderable: true, + color: true, + depth: false, + stencil: false, + storage: true, + copyable: true, + bytesPerBlock: 16, + blockWidth: 1, + blockHeight: 1, + }, + // Depth/stencil formats + depth32float: { + renderable: true, + color: false, + depth: true, + stencil: false, + storage: false, + copyable: true, + bytesPerBlock: 4, + blockWidth: 1, + blockHeight: 1, + }, + depth24plus: { + renderable: true, + color: false, + depth: true, + stencil: false, + storage: false, + copyable: false, + }, + 'depth24plus-stencil8': { + renderable: true, + color: false, + depth: true, + stencil: true, + storage: false, + copyable: false, + }, +}; + +export const kTextureFormats = keysOf(kTextureFormatInfo); + +export const kTextureDimensionInfo = { + '1d': {}, + '2d': {}, + '3d': {}, +}; + +export const kTextureDimensions = keysOf(kTextureDimensionInfo); + +export const kTextureAspectInfo = { + all: {}, + 'depth-only': {}, + 'stencil-only': {}, +}; + +export const kTextureAspects = keysOf(kTextureAspectInfo); + +export const kTextureUsageInfo = { + [GPUTextureUsage.COPY_SRC]: {}, + [GPUTextureUsage.COPY_DST]: {}, + [GPUTextureUsage.SAMPLED]: {}, + [GPUTextureUsage.STORAGE]: {}, + [GPUTextureUsage.OUTPUT_ATTACHMENT]: {}, +}; + +export const kTextureUsages = numericKeysOf(kTextureUsageInfo); + +export const kTextureComponentTypeInfo = { + float: {}, + sint: {}, + uint: {}, +}; + +export const kTextureComponentTypes = keysOf(kTextureComponentTypeInfo); + +// Texture View + +export const kTextureViewDimensionInfo = { + '1d': {}, + '2d': {}, + '2d-array': {}, + cube: {}, + 'cube-array': {}, + '3d': {}, +}; + +export const kTextureViewDimensions = keysOf(kTextureViewDimensionInfo); + +// Typedefs for bindings + +// Bindings + +export const kMaxBindingsPerBindGroup = 16; + +export const kPerStageBindingLimits = { + uniformBuf: { class: 'uniformBuf', max: 12 }, + storageBuf: { class: 'storageBuf', max: 4 }, + sampler: { class: 'sampler', max: 16 }, + sampledTex: { class: 'sampledTex', max: 16 }, + storageTex: { class: 'storageTex', max: 4 }, +}; + +export const kPerPipelineBindingLimits = { + uniformBuf: { class: 'uniformBuf', maxDynamic: 8 }, + storageBuf: { class: 'storageBuf', maxDynamic: 4 }, + sampler: { class: 'sampler', maxDynamic: 0 }, + sampledTex: { class: 'sampledTex', maxDynamic: 0 }, + storageTex: { class: 'storageTex', maxDynamic: 0 }, +}; + +const kBindableResource = { + uniformBuf: {}, + storageBuf: {}, + plainSamp: {}, + compareSamp: {}, + sampledTex: {}, + storageTex: {}, + errorBuf: {}, + errorSamp: {}, + errorTex: {}, +}; + +export const kBindableResources = keysOf(kBindableResource); + +const kBindingKind = { + uniformBuf: { + resource: 'uniformBuf', + perStageLimitClass: kPerStageBindingLimits.uniformBuf, + perPipelineLimitClass: kPerPipelineBindingLimits.uniformBuf, + }, + storageBuf: { + resource: 'storageBuf', + perStageLimitClass: kPerStageBindingLimits.storageBuf, + perPipelineLimitClass: kPerPipelineBindingLimits.storageBuf, + }, + plainSamp: { + resource: 'plainSamp', + perStageLimitClass: kPerStageBindingLimits.sampler, + perPipelineLimitClass: kPerPipelineBindingLimits.sampler, + }, + compareSamp: { + resource: 'compareSamp', + perStageLimitClass: kPerStageBindingLimits.sampler, + perPipelineLimitClass: kPerPipelineBindingLimits.sampler, + }, + sampledTex: { + resource: 'sampledTex', + perStageLimitClass: kPerStageBindingLimits.sampledTex, + perPipelineLimitClass: kPerPipelineBindingLimits.sampledTex, + }, + storageTex: { + resource: 'storageTex', + perStageLimitClass: kPerStageBindingLimits.storageTex, + perPipelineLimitClass: kPerPipelineBindingLimits.storageTex, + }, +}; + +// Binding type info + +const kValidStagesAll = { + validStages: GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT | GPUShaderStage.COMPUTE, +}; + +const kValidStagesStorageWrite = { validStages: GPUShaderStage.FRAGMENT | GPUShaderStage.COMPUTE }; + +export const kBufferBindingTypeInfo = { + 'uniform-buffer': { + usage: GPUBufferUsage.UNIFORM, + ...kBindingKind.uniformBuf, + ...kValidStagesAll, + }, + 'storage-buffer': { + usage: GPUBufferUsage.STORAGE, + ...kBindingKind.storageBuf, + ...kValidStagesStorageWrite, + }, + 'readonly-storage-buffer': { + usage: GPUBufferUsage.STORAGE, + ...kBindingKind.storageBuf, + ...kValidStagesAll, + }, +}; + +export const kBufferBindingTypes = keysOf(kBufferBindingTypeInfo); + +export const kSamplerBindingTypeInfo = { + sampler: { ...kBindingKind.plainSamp, ...kValidStagesAll }, + 'comparison-sampler': { ...kBindingKind.compareSamp, ...kValidStagesAll }, +}; + +export const kSamplerBindingTypes = keysOf(kSamplerBindingTypeInfo); + +export const kTextureBindingTypeInfo = { + 'sampled-texture': { + usage: GPUTextureUsage.SAMPLED, + ...kBindingKind.sampledTex, + ...kValidStagesAll, + }, + 'writeonly-storage-texture': { + usage: GPUTextureUsage.STORAGE, + ...kBindingKind.storageTex, + ...kValidStagesStorageWrite, + }, + 'readonly-storage-texture': { + usage: GPUTextureUsage.STORAGE, + ...kBindingKind.storageTex, + ...kValidStagesAll, + }, +}; + +export const kTextureBindingTypes = keysOf(kTextureBindingTypeInfo); + +// All binding types (merged from above) + +export const kBindingTypeInfo = { + ...kBufferBindingTypeInfo, + ...kSamplerBindingTypeInfo, + ...kTextureBindingTypeInfo, +}; + +export const kBindingTypes = keysOf(kBindingTypeInfo); + +export const kShaderStages = [ + GPUShaderStage.VERTEX, + GPUShaderStage.FRAGMENT, + GPUShaderStage.COMPUTE, +]; + +export const kShaderStageCombinations = [0, 1, 2, 3, 4, 5, 6, 7]; diff --git a/tests/wpt/webgpu/tests/webgpu/webgpu/examples.spec.js b/tests/wpt/webgpu/tests/webgpu/webgpu/examples.spec.js new file mode 100644 index 00000000000..0d741fec3c2 --- /dev/null +++ b/tests/wpt/webgpu/tests/webgpu/webgpu/examples.spec.js @@ -0,0 +1,103 @@ +/** + * AUTO-GENERATED - DO NOT EDIT. Source: https://github.com/gpuweb/cts + **/ export const description = ` +Examples of writing CTS tests with various features. + +Start here when looking for examples of basic framework usage. +`; +import { makeTestGroup } from '../common/framework/test_group.js'; + +import { GPUTest } from './gpu_test.js'; + +// To run these tests in the standalone runner, run `grunt build` or `grunt pre` then open: +// - http://localhost:8080/?runnow=1&q=webgpu:examples: +// To run in WPT, copy/symlink the out-wpt/ directory as the webgpu/ directory in WPT, then open: +// - (wpt server url)/webgpu/cts.html?q=webgpu:examples: +// +// Tests here can be run individually or in groups: +// - ?q=webgpu:examples:basic/async= +// - ?q=webgpu:examples:basic/ +// - ?q=webgpu:examples: + +export const g = makeTestGroup(GPUTest); + +// Note: spaces in test names are replaced with underscores: webgpu:examples:test_name= + +g.test('test_name').fn(t => {}); + +g.test('basic').fn(t => { + t.expect(true); + t.expect(true, 'true should be true'); + + t.shouldThrow( + // The expected '.name' of the thrown error. + 'TypeError', + // This function is run inline inside shouldThrow, and is expected to throw. + () => { + throw new TypeError(); + }, + // Log message. + 'function should throw Error' + ); +}); + +g.test('basic,async').fn(async t => { + // shouldReject must be awaited to ensure it can wait for the promise before the test ends. + t.shouldReject( + // The expected '.name' of the thrown error. + 'TypeError', + // Promise expected to reject. + Promise.reject(new TypeError()), + // Log message. + 'Promise.reject should reject' + ); + + // Promise can also be an IIFE. + t.shouldReject( + 'TypeError', + (async () => { + throw new TypeError(); + })(), + 'Promise.reject should reject' + ); +}); + +// A test can be parameterized with a simple array of objects. +// +// Parameters can be public (x, y) which means they're part of the case name. +// They can also be private by starting with an underscore (_result), which passes +// them into the test but does not make them part of the case name: +// +// - webgpu:examples:basic/params={"x":2,"y":4} runs with t.params = {x: 2, y: 5, _result: 6}. +// - webgpu:examples:basic/params={"x":-10,"y":18} runs with t.params = {x: -10, y: 18, _result: 8}. +g.test('basic,params') + .params([ + { x: 2, y: 4, _result: 6 }, // + { x: -10, y: 18, _result: 8 }, + ]) + .fn(t => { + t.expect(t.params.x + t.params.y === t.params._result); + }); +// (note the blank comment above to enforce newlines on autoformat) + +g.test('gpu,async').fn(async t => { + const fence = t.queue.createFence(); + t.queue.signal(fence, 2); + await fence.onCompletion(1); + t.expect(fence.getCompletedValue() === 2); +}); + +g.test('gpu,buffers').fn(async t => { + const data = new Uint32Array([0, 1234, 0]); + const [src, map] = t.device.createBufferMapped({ + size: 12, + usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST, + }); + + new Uint32Array(map).set(data); + src.unmap(); + + // Use the expectContents helper to check the actual contents of a GPUBuffer. + // Like shouldReject, it must be awaited. + t.expectContents(src, data); +}); diff --git a/tests/wpt/webgpu/tests/webgpu/webgpu/gpu_test.js b/tests/wpt/webgpu/tests/webgpu/webgpu/gpu_test.js new file mode 100644 index 00000000000..a0163bb3ef3 --- /dev/null +++ b/tests/wpt/webgpu/tests/webgpu/webgpu/gpu_test.js @@ -0,0 +1,292 @@ +/** + * AUTO-GENERATED - DO NOT EDIT. Source: https://github.com/gpuweb/cts + **/ function _defineProperty(obj, key, value) { + if (key in obj) { + Object.defineProperty(obj, key, { + value: value, + enumerable: true, + configurable: true, + writable: true, + }); + } else { + obj[key] = value; + } + return obj; +} +import { Fixture } from '../common/framework/fixture.js'; +import { compileGLSL, initGLSL } from '../common/framework/glsl.js'; +import { DevicePool, TestOOMedShouldAttemptGC } from '../common/framework/gpu/device_pool.js'; +import { attemptGarbageCollection } from '../common/framework/util/collect_garbage.js'; +import { assert } from '../common/framework/util/util.js'; + +import { fillTextureDataWithTexelValue, getTextureCopyLayout } from './util/texture/layout.js'; +import { getTexelDataRepresentation } from './util/texture/texelData.js'; + +const devicePool = new DevicePool(); + +export class GPUTest extends Fixture { + constructor(...args) { + super(...args); + _defineProperty(this, 'objects', undefined); + _defineProperty(this, 'initialized', false); + } + + get device() { + assert(this.objects !== undefined); + return this.objects.device; + } + + get queue() { + assert(this.objects !== undefined); + return this.objects.queue; + } + + async init() { + await super.init(); + await initGLSL(); + + const device = await devicePool.acquire(); + const queue = device.defaultQueue; + this.objects = { device, queue }; + } + + // Note: finalize is called even if init was unsuccessful. + async finalize() { + await super.finalize(); + + if (this.objects) { + let threw; + { + const objects = this.objects; + this.objects = undefined; + try { + await devicePool.release(objects.device); + } catch (ex) { + threw = ex; + } + } + // The GPUDevice and GPUQueue should now have no outstanding references. + + if (threw) { + if (threw instanceof TestOOMedShouldAttemptGC) { + // Try to clean up, in case there are stray GPU resources in need of collection. + await attemptGarbageCollection(); + } + throw threw; + } + } + } + + makeShaderModule(stage, code) { + // If both are provided, always choose WGSL. (Can change this if needed.) + if ('wgsl' in code) { + return this.device.createShaderModule({ code: code.wgsl }); + } else { + const spirv = compileGLSL(code.glsl, stage, false); + return this.device.createShaderModule({ code: spirv }); + } + } + + createCopyForMapRead(src, start, size) { + const dst = this.device.createBuffer({ + size, + usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST, + }); + + const c = this.device.createCommandEncoder(); + c.copyBufferToBuffer(src, start, dst, 0, size); + + this.queue.submit([c.finish()]); + + return dst; + } + + // TODO: add an expectContents for textures, which logs data: uris on failure + + expectContents(src, expected) { + this.expectSubContents(src, 0, expected); + } + + expectSubContents(src, start, expected) { + const dst = this.createCopyForMapRead(src, start, expected.buffer.byteLength); + + this.eventualAsyncExpectation(async niceStack => { + const constructor = expected.constructor; + const actual = new constructor(await dst.mapReadAsync()); + const check = this.checkBuffer(actual, expected); + if (check !== undefined) { + niceStack.message = check; + this.rec.expectationFailed(niceStack); + } + dst.destroy(); + }); + } + + expectBuffer(actual, exp) { + const check = this.checkBuffer(actual, exp); + if (check !== undefined) { + this.rec.expectationFailed(new Error(check)); + } + } + + checkBuffer(actual, exp, tolerance = 0) { + assert(actual.constructor === exp.constructor); + + const size = exp.byteLength; + if (actual.byteLength !== size) { + return 'size mismatch'; + } + const failedByteIndices = []; + const failedByteExpectedValues = []; + const failedByteActualValues = []; + for (let i = 0; i < size; ++i) { + const tol = typeof tolerance === 'function' ? tolerance(i) : tolerance; + if (Math.abs(actual[i] - exp[i]) > tol) { + if (failedByteIndices.length >= 4) { + failedByteIndices.push('...'); + failedByteExpectedValues.push('...'); + failedByteActualValues.push('...'); + break; + } + failedByteIndices.push(i.toString()); + failedByteExpectedValues.push(exp[i].toString()); + failedByteActualValues.push(actual[i].toString()); + } + } + const summary = `at [${failedByteIndices.join(', ')}], \ +expected [${failedByteExpectedValues.join(', ')}], \ +got [${failedByteActualValues.join(', ')}]`; + const lines = [summary]; + + // TODO: Could make a more convenient message, which could look like e.g.: + // + // Starting at offset 48, + // got 22222222 ABCDABCD 99999999 + // but expected 22222222 55555555 99999999 + // + // or + // + // Starting at offset 0, + // got 00000000 00000000 00000000 00000000 (... more) + // but expected 00FF00FF 00FF00FF 00FF00FF 00FF00FF (... more) + // + // Or, maybe these diffs aren't actually very useful (given we have the prints just above here), + // and we should remove them. More important will be logging of texture data in a visual format. + + if (size <= 256 && failedByteIndices.length > 0) { + const expHex = Array.from(new Uint8Array(exp.buffer, exp.byteOffset, exp.byteLength)) + .map(x => x.toString(16).padStart(2, '0')) + .join(''); + const actHex = Array.from(new Uint8Array(actual.buffer, actual.byteOffset, actual.byteLength)) + .map(x => x.toString(16).padStart(2, '0')) + .join(''); + lines.push('EXPECT:\t ' + exp.join(' ')); + lines.push('\t0x' + expHex); + lines.push('ACTUAL:\t ' + actual.join(' ')); + lines.push('\t0x' + actHex); + } + if (failedByteIndices.length) { + return lines.join('\n'); + } + return undefined; + } + + expectSingleColor(src, format, { size, exp, dimension = '2d', slice = 0, layout }) { + const { byteLength, bytesPerRow, rowsPerImage, mipSize } = getTextureCopyLayout( + format, + dimension, + size, + layout + ); + + const expectedTexelData = getTexelDataRepresentation(format).getBytes(exp); + + const buffer = this.device.createBuffer({ + size: byteLength, + usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST, + }); + + const commandEncoder = this.device.createCommandEncoder(); + commandEncoder.copyTextureToBuffer( + { + texture: src, + mipLevel: layout === null || layout === void 0 ? void 0 : layout.mipLevel, + origin: { x: 0, y: 0, z: slice }, + }, + { buffer, bytesPerRow, rowsPerImage }, + mipSize + ); + + this.queue.submit([commandEncoder.finish()]); + const arrayBuffer = new ArrayBuffer(byteLength); + fillTextureDataWithTexelValue(expectedTexelData, format, dimension, arrayBuffer, size, layout); + this.expectContents(buffer, new Uint8Array(arrayBuffer)); + } + + // TODO: Add check for values of depth/stencil, probably through sampling of shader + // TODO(natashalee): Can refactor this and expectSingleColor to use a similar base expect + expectSinglePixelIn2DTexture(src, format, { x, y }, { exp, slice = 0, layout }) { + const { byteLength, bytesPerRow, rowsPerImage, mipSize } = getTextureCopyLayout( + format, + '2d', + [1, 1, 1], + layout + ); + + const buffer = this.device.createBuffer({ + size: byteLength, + usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST, + }); + + const commandEncoder = this.device.createCommandEncoder(); + commandEncoder.copyTextureToBuffer( + { + texture: src, + mipLevel: layout === null || layout === void 0 ? void 0 : layout.mipLevel, + origin: { x, y, z: slice }, + }, + { buffer, bytesPerRow, rowsPerImage }, + mipSize + ); + + this.queue.submit([commandEncoder.finish()]); + + this.expectContents(buffer, exp); + } + + expectGPUError(filter, fn) { + this.device.pushErrorScope(filter); + const returnValue = fn(); + const promise = this.device.popErrorScope(); + + this.eventualAsyncExpectation(async niceStack => { + const error = await promise; + + let failed = false; + switch (filter) { + case 'none': + failed = error !== null; + break; + case 'out-of-memory': + failed = !(error instanceof GPUOutOfMemoryError); + break; + case 'validation': + failed = !(error instanceof GPUValidationError); + break; + } + + if (failed) { + niceStack.message = `Expected ${filter} error`; + this.rec.expectationFailed(niceStack); + } else { + niceStack.message = `Captured ${filter} error`; + if (error instanceof GPUValidationError) { + niceStack.message += ` - ${error.message}`; + } + this.rec.debug(niceStack); + } + }); + + return returnValue; + } +} diff --git a/tests/wpt/webgpu/tests/webgpu/webgpu/idl/constants/flags.spec.js b/tests/wpt/webgpu/tests/webgpu/webgpu/idl/constants/flags.spec.js new file mode 100644 index 00000000000..1de75c84e5d --- /dev/null +++ b/tests/wpt/webgpu/tests/webgpu/webgpu/idl/constants/flags.spec.js @@ -0,0 +1,59 @@ +/** + * AUTO-GENERATED - DO NOT EDIT. Source: https://github.com/gpuweb/cts + **/ export const description = ` +Test the values of flags interfaces (e.g. GPUTextureUsage). +`; +import { makeTestGroup } from '../../../common/framework/test_group.js'; +import { IDLTest } from '../idl_test.js'; + +export const g = makeTestGroup(IDLTest); + +g.test('BufferUsage').fn(t => { + const expected = { + MAP_READ: 0x0001, + MAP_WRITE: 0x0002, + COPY_SRC: 0x0004, + COPY_DST: 0x0008, + INDEX: 0x0010, + VERTEX: 0x0020, + UNIFORM: 0x0040, + STORAGE: 0x0080, + INDIRECT: 0x0100, + }; + + t.assertMembers(GPUBufferUsage, expected); +}); + +g.test('TextureUsage').fn(t => { + const expected = { + COPY_SRC: 0x01, + COPY_DST: 0x02, + SAMPLED: 0x04, + STORAGE: 0x08, + OUTPUT_ATTACHMENT: 0x10, + }; + + t.assertMembers(GPUTextureUsage, expected); +}); + +g.test('ColorWrite').fn(t => { + const expected = { + RED: 0x1, + GREEN: 0x2, + BLUE: 0x4, + ALPHA: 0x8, + ALL: 0xf, + }; + + t.assertMembers(GPUColorWrite, expected); +}); + +g.test('ShaderStage').fn(t => { + const expected = { + VERTEX: 0x1, + FRAGMENT: 0x2, + COMPUTE: 0x4, + }; + + t.assertMembers(GPUShaderStage, expected); +}); diff --git a/tests/wpt/webgpu/tests/webgpu/webgpu/idl/idl_test.js b/tests/wpt/webgpu/tests/webgpu/webgpu/idl/idl_test.js new file mode 100644 index 00000000000..231fc0945f8 --- /dev/null +++ b/tests/wpt/webgpu/tests/webgpu/webgpu/idl/idl_test.js @@ -0,0 +1,25 @@ +/** + * AUTO-GENERATED - DO NOT EDIT. Source: https://github.com/gpuweb/cts + **/ import { Fixture } from '../../common/framework/fixture.js'; +import { assert } from '../../common/framework/util/util.js'; + +export class IDLTest extends Fixture { + /** + * Asserts that an IDL interface has the expected members. + */ + // TODO: exp should allow sentinel markers for unnameable values, such as methods and attributes + // TODO: handle extensions + // TODO: check prototype chains (maybe as separate method) + assertMembers(act, exp) { + const expKeys = Object.keys(exp); + for (const k of expKeys) { + assert(k in act, () => `Expected key ${k} missing`); + assert(act[k] === exp[k], () => `Value of [${k}] was ${act[k]}, expected ${exp[k]}`); + } + const actKeys = Object.keys(act); + assert( + actKeys.length === expKeys.length, + () => `Had ${actKeys.length} keys, expected ${expKeys.length}` + ); + } +} diff --git a/tests/wpt/webgpu/tests/webgpu/webgpu/listing.js b/tests/wpt/webgpu/tests/webgpu/webgpu/listing.js new file mode 100644 index 00000000000..51bba64a493 --- /dev/null +++ b/tests/wpt/webgpu/tests/webgpu/webgpu/listing.js @@ -0,0 +1,437 @@ +// AUTO-GENERATED - DO NOT EDIT. See src/common/tools/gen_listings.ts. + +export const listing = [ + { + "file": [], + "readme": "WebGPU conformance test suite." + }, + { + "file": [ + "api" + ], + "readme": "Tests for full coverage of the Javascript API surface of WebGPU." + }, + { + "file": [ + "api", + "operation" + ], + "readme": "Tests that check the result of performing valid WebGPU operations, taking advantage of\nparameterization to exercise interactions between features." + }, + { + "file": [ + "api", + "operation", + "buffers" + ], + "readme": "GPUBuffer tests." + }, + { + "file": [ + "api", + "operation", + "buffers", + "create_mapped" + ], + "description": "" + }, + { + "file": [ + "api", + "operation", + "buffers", + "map" + ], + "description": "" + }, + { + "file": [ + "api", + "operation", + "buffers", + "map_detach" + ], + "description": "" + }, + { + "file": [ + "api", + "operation", + "buffers", + "map_oom" + ], + "description": "" + }, + { + "file": [ + "api", + "operation", + "command_buffer", + "basic" + ], + "description": "Basic tests." + }, + { + "file": [ + "api", + "operation", + "command_buffer", + "compute", + "basic" + ], + "description": "Basic command buffer compute tests." + }, + { + "file": [ + "api", + "operation", + "command_buffer", + "copies" + ], + "description": "copy{Buffer,Texture}To{Buffer,Texture} tests." + }, + { + "file": [ + "api", + "operation", + "command_buffer", + "render", + "basic" + ], + "description": "Basic command buffer rendering tests." + }, + { + "file": [ + "api", + "operation", + "command_buffer", + "render", + "rendering" + ], + "description": "" + }, + { + "file": [ + "api", + "operation", + "command_buffer", + "render", + "storeop" + ], + "description": "renderPass store op test that drawn quad is either stored or cleared based on storeop" + }, + { + "file": [ + "api", + "operation", + "fences" + ], + "description": "" + }, + { + "file": [ + "api", + "operation", + "render_pass", + "storeOp" + ], + "description": "API Operation Tests for RenderPass StoreOp.\n\n Test Coverage Needed:\n\n - Test that a render pass has correct output for combinations of:\n - All color attachments from '0' to 'MAX_COLOR_ATTACHMENTS' with combinations of:\n - storeOp set to {'clear', 'store', 'undefined}\n - All color renderable formats\n - mip level set to {'0', mip > '0'}\n - array layer set to {'0', layer > '1'} for 2D textures\n - depth slice set to {'0', slice > '0'} for 3D textures\n - With and without a depthStencilAttachment that has the combinations of:\n - depthStoreOp set to {'clear', 'store', 'undefined'}\n - stencilStoreOp set to {'clear', 'store', 'undefined'}\n - All depth/stencil formats\n - mip level set to {'0', mip > '0'}\n - array layer set to {'0', layer > '1'} for 2D textures\n - depth slice set to {'0', slice > '0'} for 3D textures" + }, + { + "file": [ + "api", + "operation", + "render_pipeline", + "culling_tests" + ], + "description": "Test culling and rasterizaion state.\n\nTest coverage:\nTest all culling combinations of GPUFrontFace and GPUCullMode show the correct output.\n\nUse 2 triangles with different winding orders:\n\n- Test that the counter-clock wise triangle has correct output for:\n - All FrontFaces (ccw, cw)\n - All CullModes (none, front, back)\n - All depth stencil attachment types (none, depth24plus, depth32float, depth24plus-stencil8)\n - Some primitive topologies (triangle-list, TODO: triangle-strip)\n\n- Test that the clock wise triangle has correct output for:\n - All FrontFaces (ccw, cw)\n - All CullModes (none, front, back)\n - All depth stencil attachment types (none, depth24plus, depth32float, depth24plus-stencil8)\n - Some primitive topologies (triangle-list, TODO: triangle-strip)" + }, + { + "file": [ + "api", + "operation", + "resource_init", + "copied_texture_clear" + ], + "description": "Test uninitialized textures are initialized to zero when copied." + }, + { + "file": [ + "api", + "operation", + "resource_init", + "depth_stencil_attachment_clear" + ], + "description": "Test uninitialized textures are initialized to zero when used as a depth/stencil attachment." + }, + { + "file": [ + "api", + "operation", + "resource_init", + "sampled_texture_clear" + ], + "description": "Test uninitialized textures are initialized to zero when sampled." + }, + { + "file": [ + "api", + "regression" + ], + "readme": "One-off tests that reproduce API bugs found in implementations to prevent the bugs from\nappearing again." + }, + { + "file": [ + "api", + "validation" + ], + "readme": "Positive and negative tests for all the validation rules of the API." + }, + { + "file": [ + "api", + "validation", + "createBindGroup" + ], + "description": "createBindGroup validation tests." + }, + { + "file": [ + "api", + "validation", + "createBindGroupLayout" + ], + "description": "createBindGroupLayout validation tests." + }, + { + "file": [ + "api", + "validation", + "createPipelineLayout" + ], + "description": "createPipelineLayout validation tests." + }, + { + "file": [ + "api", + "validation", + "createRenderPipeline" + ], + "description": "createRenderPipeline validation tests." + }, + { + "file": [ + "api", + "validation", + "createTexture" + ], + "description": "createTexture validation tests." + }, + { + "file": [ + "api", + "validation", + "createView" + ], + "description": "createView validation tests." + }, + { + "file": [ + "api", + "validation", + "encoding", + "cmds", + "index_access" + ], + "description": "indexed draws validation tests." + }, + { + "file": [ + "api", + "validation", + "error_scope" + ], + "description": "error scope validation tests." + }, + { + "file": [ + "api", + "validation", + "fences" + ], + "description": "fences validation tests." + }, + { + "file": [ + "api", + "validation", + "queue_submit" + ], + "description": "queue submit validation tests." + }, + { + "file": [ + "api", + "validation", + "render_pass" + ], + "description": "render pass validation tests." + }, + { + "file": [ + "api", + "validation", + "render_pass", + "storeOp" + ], + "description": "API Validation Tests for RenderPass StoreOp.\n\n Test Coverage Needed:\n\n - Test that when depthReadOnly is true, depthStoreOp must be 'store'\n\n - Test that when stencilReadOnly is true, stencilStoreOp must be 'store'" + }, + { + "file": [ + "api", + "validation", + "render_pass_descriptor" + ], + "description": "render pass descriptor validation tests." + }, + { + "file": [ + "api", + "validation", + "setBindGroup" + ], + "description": "setBindGroup validation tests." + }, + { + "file": [ + "api", + "validation", + "setBlendColor" + ], + "description": "setBlendColor validation tests." + }, + { + "file": [ + "api", + "validation", + "setScissorRect" + ], + "description": "setScissorRect validation tests." + }, + { + "file": [ + "api", + "validation", + "setStencilReference" + ], + "description": "setStencilReference validation tests." + }, + { + "file": [ + "api", + "validation", + "setVertexBuffer" + ], + "description": "setVertexBuffer validation tests." + }, + { + "file": [ + "api", + "validation", + "setViewport" + ], + "description": "setViewport validation tests." + }, + { + "file": [ + "api", + "validation", + "vertex_state" + ], + "description": "vertexState validation tests." + }, + { + "file": [ + "examples" + ], + "description": "Examples of writing CTS tests with various features.\n\nStart here when looking for examples of basic framework usage." + }, + { + "file": [ + "idl" + ], + "readme": "Tests to check that the WebGPU IDL is correctly implemented, for examples that objects exposed\nexactly the correct members, and that methods throw when passed incomplete dictionaries." + }, + { + "file": [ + "idl", + "constants", + "flags" + ], + "description": "Test the values of flags interfaces (e.g. GPUTextureUsage)." + }, + { + "file": [ + "shader" + ], + "readme": "Tests for full coverage of the shaders that can be passed to WebGPU." + }, + { + "file": [ + "shader", + "execution" + ], + "readme": "Tests that check the result of valid shader execution." + }, + { + "file": [ + "shader", + "execution", + "robust_access" + ], + "description": "Tests to check array clamping in shaders is correctly implemented including vector / matrix indexing" + }, + { + "file": [ + "shader", + "execution", + "robust_access_vertex" + ], + "description": "Test vertex attributes behave correctly (no crash / data leak) when accessed out of bounds\n\nTest coverage:\n\nThe following will be parameterized (all combinations tested):\n\n1) Draw call indexed? (false / true)\n - Run the draw call using an index buffer\n\n2) Draw call indirect? (false / true)\n - Run the draw call using an indirect buffer\n\n3) Draw call parameter (vertexCount, firstVertex, indexCount, firstIndex, baseVertex, instanceCount,\n firstInstance)\n - The parameter which will go out of bounds. Filtered depending on if the draw call is indexed.\n\n4) Attribute type (float, vec2, vec3, vec4)\n - The input attribute type in the vertex shader\n\n5) Error scale (1, 4, 10^2, 10^4, 10^6)\n - Offset to add to the correct draw call parameter\n\n6) Additional vertex buffers (0, +4)\n - Tests that no OOB occurs if more vertex buffers are used\n\nThe tests will also have another vertex buffer bound for an instanced attribute, to make sure\ninstanceCount / firstInstance are tested.\n\nThe tests will include multiple attributes per vertex buffer.\n\nThe vertex buffers will be filled by repeating a few chosen values until the end of the buffer.\n\nThe test will run a render pipeline which verifies the following:\n1) All vertex attribute values occur in the buffer or are zero\n2) All gl_VertexIndex values are within the index buffer or 0\n\nTODO:\n\nA suppression may be needed for d3d12 on tests that have non-zero baseVertex, since d3d12 counts\nfrom 0 instead of from baseVertex (will fail check for gl_VertexIndex).\n\nVertex buffer contents could be randomized to prevent the case where a previous test creates\na similar buffer to ours and the OOB-read seems valid. This should be deterministic, which adds\nmore complexity that we may not need." + }, + { + "file": [ + "shader", + "regression" + ], + "readme": "One-off tests that reproduce shader bugs found in implementations to prevent the bugs from\nappearing again." + }, + { + "file": [ + "shader", + "validation" + ], + "readme": "Positive and negative tests for all the validation rules of the shading language." + }, + { + "file": [ + "web-platform" + ], + "readme": "Tests for Web platform-specific interactions like GPUSwapChain and canvas, WebXR,\nImageBitmaps, and video APIs." + }, + { + "file": [ + "web-platform", + "canvas", + "context_creation" + ], + "description": "" + }, + { + "file": [ + "web-platform", + "copyImageBitmapToTexture" + ], + "description": "copy imageBitmap To texture tests." + } +]; diff --git a/tests/wpt/webgpu/tests/webgpu/webgpu/shader/execution/robust_access.spec.js b/tests/wpt/webgpu/tests/webgpu/webgpu/shader/execution/robust_access.spec.js new file mode 100644 index 00000000000..0fe4a36ad10 --- /dev/null +++ b/tests/wpt/webgpu/tests/webgpu/webgpu/shader/execution/robust_access.spec.js @@ -0,0 +1,337 @@ +/** + * AUTO-GENERATED - DO NOT EDIT. Source: https://github.com/gpuweb/cts + **/ export const description = ` +Tests to check array clamping in shaders is correctly implemented including vector / matrix indexing +`; +import { params, poptions } from '../../../common/framework/params_builder.js'; +import { makeTestGroup } from '../../../common/framework/test_group.js'; +import { assert } from '../../../common/framework/util/util.js'; +import { GPUTest } from '../../gpu_test.js'; + +export const g = makeTestGroup(GPUTest); + +// Utilities that should probably live in some shared place. +function copyArrayBuffer(src) { + const dst = new ArrayBuffer(src.byteLength); + new Uint8Array(dst).set(new Uint8Array(src)); + return dst; +} + +const kUintMax = 4294967295; +const kIntMax = 2147483647; + +// A small utility to test shaders: +// - it wraps the source into a small harness that checks the runTest() function returns 0. +// - it runs the shader with the testBindings set as bindgroup 0. +// +// The shader also has access to a uniform value that's equal to 1u to avoid constant propagation +// in the shader compiler. +function runShaderTest(t, stage, testSource, testBindings) { + assert(stage === GPUShaderStage.COMPUTE, 'Only know how to deal with compute for now'); + + const [constantsBuffer, constantsInit] = t.device.createBufferMapped({ + size: 4, + usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.UNIFORM, + }); + + const constantsData = new Uint32Array(constantsInit); + constantsData[0] = 1; + constantsBuffer.unmap(); + + const resultBuffer = t.device.createBuffer({ + size: 4, + usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE, + }); + + const source = `#version 450 + layout(std140, set = 1, binding = 0) uniform Constants { + uint one; + }; + layout(std430, set = 1, binding = 1) buffer Result { + uint result; + }; + + ${testSource} + + void main() { + result = runTest(); + }`; + + const pipeline = t.device.createComputePipeline({ + computeStage: { + entryPoint: 'main', + module: t.makeShaderModule('compute', { glsl: source }), + }, + }); + + const group = t.device.createBindGroup({ + layout: pipeline.getBindGroupLayout(1), + entries: [ + { binding: 0, resource: { buffer: constantsBuffer } }, + { binding: 1, resource: { buffer: resultBuffer } }, + ], + }); + + const testGroup = t.device.createBindGroup({ + layout: pipeline.getBindGroupLayout(0), + entries: testBindings, + }); + + const encoder = t.device.createCommandEncoder(); + const pass = encoder.beginComputePass(); + pass.setPipeline(pipeline); + pass.setBindGroup(0, testGroup); + pass.setBindGroup(1, group); + pass.dispatch(1); + pass.endPass(); + + t.queue.submit([encoder.finish()]); + + t.expectContents(resultBuffer, new Uint32Array([0])); +} + +// The definition of base types for aggregate types, for example float, uint, etc. + +const baseTypes = { + // TODO bools + uint: { + name: 'uint', + byteSize: 4, + glslPrefix: 'u', + glslZero: '0u', + fillBuffer(data, zeroStart, size) { + const typedData = new Uint32Array(data); + typedData.fill(42); + for (let i = 0; i < size / 4; i++) { + typedData[zeroStart / 4 + i] = 0; + } + }, + }, + + int: { + name: 'int', + byteSize: 4, + glslPrefix: 'i', + glslZero: '0', + fillBuffer(data, zeroStart, size) { + const typedData = new Int32Array(data); + typedData.fill(42); + for (let i = 0; i < size / 4; i++) { + typedData[zeroStart / 4 + i] = 0; + } + }, + }, + + float: { + name: 'float', + byteSize: 4, + glslPrefix: '', + glslZero: '0.0f', + fillBuffer(data, zeroStart, size) { + const typedData = new Float32Array(data); + typedData.fill(42); + for (let i = 0; i < size / 4; i++) { + typedData[zeroStart / 4 + i] = 0; + } + }, + }, + + bool: { + name: 'bool', + byteSize: 4, + glslPrefix: 'b', + glslZero: 'false', + fillBuffer(data, zeroStart, size) { + const typedData = new Uint32Array(data); + typedData.fill(42); + for (let i = 0; i < size / 4; i++) { + typedData[zeroStart / 4 + i] = 0; + } + }, + }, +}; + +// The definition of aggregate types. + +const typeParams = (() => { + const types = {}; + for (const baseTypeName of Object.keys(baseTypes)) { + const baseType = baseTypes[baseTypeName]; + + // Arrays + types[`${baseTypeName}_sizedArray`] = { + declaration: `${baseTypeName} data[3]`, + length: 3, + std140Length: 2 * 4 + 1, + std430Length: 3, + zero: baseType.glslZero, + baseType, + }; + + types[`${baseTypeName}_unsizedArray`] = { + declaration: `${baseTypeName} data[]`, + length: 3, + std140Length: 0, // Unused + std430Length: 3, + zero: baseType.glslZero, + baseType, + isUnsizedArray: true, + }; + + // Vectors + for (let dimension = 2; dimension <= 4; dimension++) { + types[`${baseTypeName}_vector${dimension}`] = { + declaration: `${baseType.glslPrefix}vec${dimension} data`, + length: dimension, + std140Length: dimension, + std430Length: dimension, + zero: baseType.glslZero, + baseType, + }; + } + } + + // Matrices, there are only float matrics in GLSL. + for (const transposed of [false, true]) { + for (let numColumns = 2; numColumns <= 4; numColumns++) { + for (let numRows = 2; numRows <= 4; numRows++) { + const majorDim = transposed ? numRows : numColumns; + const minorDim = transposed ? numColumns : numRows; + + const std140SizePerMinorDim = 4; + const std430SizePerMinorDim = minorDim === 3 ? 4 : minorDim; + + let typeName = `mat${numColumns}`; + if (numColumns !== numRows) { + typeName += `x${numRows}`; + } + + types[(transposed ? 'transposed_' : '') + typeName] = { + declaration: (transposed ? 'layout(row_major) ' : '') + `${typeName} data`, + length: numColumns, + std140Length: std140SizePerMinorDim * (majorDim - 1) + minorDim, + std430Length: std430SizePerMinorDim * (majorDim - 1) + minorDim, + zero: `vec${numRows}(0.0f)`, + baseType: baseTypes['float'], + }; + } + } + } + + return types; +})(); + +g.test('bufferMemory') + .params( + params() + .combine(poptions('type', Object.keys(typeParams))) + .combine([ + { memory: 'storage', access: 'read' }, + { memory: 'storage', access: 'write' }, + { memory: 'storage', access: 'atomic' }, + { memory: 'uniform', access: 'read' }, + ]) + + // Unsized arrays are only supported with SSBOs + .unless(p => typeParams[p.type].isUnsizedArray === true && p.memory !== 'storage') + // Atomics are only supported with integers + .unless(p => p.access === 'atomic' && !(typeParams[p.type].baseType.name in ['uint', 'int'])) + ) + .fn(async t => { + const type = typeParams[t.params.type]; + const baseType = type.baseType; + + const indicesToTest = [ + // Write to the inside of the type so we can check the size computations were correct. + '0', + `${type.length} - 1`, + + // Check exact bounds + '-1', + `${type.length}`, + + // Check large offset + '-1000000', + '1000000', + + // Check with max uint + `${kUintMax}`, + `-1 * ${kUintMax}`, + + // Check with max int + `${kIntMax}`, + `-1 * ${kIntMax}`, + ]; + + let testSource = ''; + let byteSize = 0; + + // Declare the data that will be accessed to check robust access. + if (t.params.memory === 'uniform') { + testSource += ` + layout(std140, set = 0, binding = 0) uniform TestData { + ${type.declaration}; + };`; + byteSize = baseType.byteSize * type.std140Length; + } else { + testSource += ` + layout(std430, set = 0, binding = 0) buffer TestData { + ${type.declaration}; + };`; + byteSize = baseType.byteSize * type.std430Length; + } + + // Build the test function that will do the tests. + testSource += ` + uint runTest() { + `; + + for (const indexToTest of indicesToTest) { + // TODO check with constants too. + const index = `(${indexToTest}) * one`; + + if (t.params.access === 'read') { + testSource += ` + if(data[${index}] != ${type.zero}) { + return __LINE__; + }`; + } else if (t.params.access === 'write') { + testSource += `data[${index}] = ${type.zero};`; + } else { + testSource += `atomicAdd(data[${index}], 1);`; + } + } + + testSource += ` + return 0; + }`; + + // Create a buffer that contains zeroes in the allowed access area, and 42s everywhere else. + const [testBuffer, testInit] = t.device.createBufferMapped({ + size: 512, + usage: + GPUBufferUsage.COPY_SRC | + GPUBufferUsage.UNIFORM | + GPUBufferUsage.STORAGE | + GPUBufferUsage.COPY_DST, + }); + + baseType.fillBuffer(testInit, 256, byteSize); + const testInitCopy = copyArrayBuffer(testInit); + testBuffer.unmap(); + + // Run the shader, accessing the buffer. + runShaderTest(t, GPUShaderStage.COMPUTE, testSource, [ + { binding: 0, resource: { buffer: testBuffer, offset: 256, size: byteSize } }, + ]); + + // Check that content of the buffer outside of the allowed area didn't change. + t.expectSubContents(testBuffer, 0, new Uint8Array(testInitCopy.slice(0, 256))); + const dataEnd = 256 + byteSize; + t.expectSubContents(testBuffer, dataEnd, new Uint8Array(testInitCopy.slice(dataEnd, 512))); + }); + +// TODO: also check other shader stages. +// TODO: also check global, function local, and shared variables. +// TODO: also check interface variables. +// TODO: also check storage texture access. diff --git a/tests/wpt/webgpu/tests/webgpu/webgpu/shader/execution/robust_access_vertex.spec.js b/tests/wpt/webgpu/tests/webgpu/webgpu/shader/execution/robust_access_vertex.spec.js new file mode 100644 index 00000000000..05b83fd049c --- /dev/null +++ b/tests/wpt/webgpu/tests/webgpu/webgpu/shader/execution/robust_access_vertex.spec.js @@ -0,0 +1,451 @@ +/** + * AUTO-GENERATED - DO NOT EDIT. Source: https://github.com/gpuweb/cts + **/ function _defineProperty(obj, key, value) { + if (key in obj) { + Object.defineProperty(obj, key, { + value: value, + enumerable: true, + configurable: true, + writable: true, + }); + } else { + obj[key] = value; + } + return obj; +} +export const description = ` +Test vertex attributes behave correctly (no crash / data leak) when accessed out of bounds + +Test coverage: + +The following will be parameterized (all combinations tested): + +1) Draw call indexed? (false / true) + - Run the draw call using an index buffer + +2) Draw call indirect? (false / true) + - Run the draw call using an indirect buffer + +3) Draw call parameter (vertexCount, firstVertex, indexCount, firstIndex, baseVertex, instanceCount, + firstInstance) + - The parameter which will go out of bounds. Filtered depending on if the draw call is indexed. + +4) Attribute type (float, vec2, vec3, vec4) + - The input attribute type in the vertex shader + +5) Error scale (1, 4, 10^2, 10^4, 10^6) + - Offset to add to the correct draw call parameter + +6) Additional vertex buffers (0, +4) + - Tests that no OOB occurs if more vertex buffers are used + +The tests will also have another vertex buffer bound for an instanced attribute, to make sure +instanceCount / firstInstance are tested. + +The tests will include multiple attributes per vertex buffer. + +The vertex buffers will be filled by repeating a few chosen values until the end of the buffer. + +The test will run a render pipeline which verifies the following: +1) All vertex attribute values occur in the buffer or are zero +2) All gl_VertexIndex values are within the index buffer or 0 + +TODO: + +A suppression may be needed for d3d12 on tests that have non-zero baseVertex, since d3d12 counts +from 0 instead of from baseVertex (will fail check for gl_VertexIndex). + +Vertex buffer contents could be randomized to prevent the case where a previous test creates +a similar buffer to ours and the OOB-read seems valid. This should be deterministic, which adds +more complexity that we may not need.`; +import { params, pbool, poptions } from '../../../common/framework/params_builder.js'; +import { makeTestGroup } from '../../../common/framework/test_group.js'; +import { GPUTest } from '../../gpu_test.js'; + +export const g = makeTestGroup(GPUTest); + +// Encapsulates a draw call (either indexed or non-indexed) +class DrawCall { + // Add a float offset when binding vertex buffer + + // Draw + + // DrawIndexed + + // Both Draw and DrawIndexed + + constructor(device, vertexArrays, vertexCount, partialLastNumber, offsetVertexBuffer) { + _defineProperty(this, 'device', void 0); + _defineProperty(this, 'vertexBuffers', void 0); + _defineProperty(this, 'indexBuffer', void 0); + _defineProperty(this, 'offsetVertexBuffer', void 0); + _defineProperty(this, 'vertexCount', void 0); + _defineProperty(this, 'firstVertex', void 0); + _defineProperty(this, 'indexCount', void 0); + _defineProperty(this, 'firstIndex', void 0); + _defineProperty(this, 'baseVertex', void 0); + _defineProperty(this, 'instanceCount', void 0); + _defineProperty(this, 'firstInstance', void 0); + this.device = device; + this.vertexBuffers = vertexArrays.map(v => this.generateVertexBuffer(v, partialLastNumber)); + + const indexArray = new Uint16Array(vertexCount).fill(0).map((_, i) => i); + this.indexBuffer = this.generateIndexBuffer(indexArray); + + // Default arguments (valid call) + this.vertexCount = vertexCount; + this.firstVertex = 0; + this.indexCount = vertexCount; + this.firstIndex = 0; + this.baseVertex = 0; + this.instanceCount = vertexCount; + this.firstInstance = 0; + + this.offsetVertexBuffer = offsetVertexBuffer; + } + + // Insert a draw call into |pass| with specified type + insertInto(pass, indexed, indirect) { + if (indexed) { + if (indirect) { + this.drawIndexedIndirect(pass); + } else { + this.drawIndexed(pass); + } + } else { + if (indirect) { + this.drawIndirect(pass); + } else { + this.draw(pass); + } + } + } + + // Insert a draw call into |pass| + draw(pass) { + this.bindVertexBuffers(pass); + pass.draw(this.vertexCount, this.instanceCount, this.firstVertex, this.firstInstance); + } + + // Insert an indexed draw call into |pass| + drawIndexed(pass) { + this.bindVertexBuffers(pass); + pass.setIndexBuffer(this.indexBuffer); + pass.drawIndexed( + this.indexCount, + this.instanceCount, + this.firstIndex, + this.baseVertex, + this.firstInstance + ); + } + + // Insert an indirect draw call into |pass| + drawIndirect(pass) { + this.bindVertexBuffers(pass); + pass.drawIndirect(this.generateIndirectBuffer(), 0); + } + + // Insert an indexed indirect draw call into |pass| + drawIndexedIndirect(pass) { + this.bindVertexBuffers(pass); + pass.setIndexBuffer(this.indexBuffer); + pass.drawIndexedIndirect(this.generateIndexedIndirectBuffer(), 0); + } + + // Bind all vertex buffers generated + bindVertexBuffers(pass) { + let currSlot = 0; + for (let i = 0; i < this.vertexBuffers.length; i++) { + pass.setVertexBuffer(currSlot++, this.vertexBuffers[i], this.offsetVertexBuffer ? 4 : 0); + } + } + + // Create a vertex buffer from |vertexArray| + // If |partialLastNumber| is true, delete one byte off the end + generateVertexBuffer(vertexArray, partialLastNumber) { + let size = vertexArray.byteLength; + if (partialLastNumber) { + size -= 1; + } + const [vertexBuffer, vertexMapping] = this.device.createBufferMapped({ + size, + usage: GPUBufferUsage.VERTEX, + }); + + if (!partialLastNumber) { + new Float32Array(vertexMapping).set(vertexArray); + } else { + new Uint8Array(vertexMapping).set(new Uint8Array(vertexArray.buffer).slice(0, size)); + } + vertexBuffer.unmap(); + return vertexBuffer; + } + + // Create an index buffer from |indexArray| + generateIndexBuffer(indexArray) { + const [indexBuffer, indexMapping] = this.device.createBufferMapped({ + size: indexArray.byteLength, + usage: GPUBufferUsage.INDEX, + }); + + new Uint16Array(indexMapping).set(indexArray); + indexBuffer.unmap(); + return indexBuffer; + } + + // Create an indirect buffer containing draw call values + generateIndirectBuffer() { + const indirectArray = new Int32Array([ + this.vertexCount, + this.instanceCount, + this.firstVertex, + this.firstInstance, + ]); + + const [indirectBuffer, indirectMapping] = this.device.createBufferMapped({ + size: indirectArray.byteLength, + usage: GPUBufferUsage.INDIRECT, + }); + + new Int32Array(indirectMapping).set(indirectArray); + indirectBuffer.unmap(); + return indirectBuffer; + } + + // Create an indirect buffer containing indexed draw call values + generateIndexedIndirectBuffer() { + const indirectArray = new Int32Array([ + this.indexCount, + this.instanceCount, + this.firstVertex, + this.baseVertex, + this.firstInstance, + ]); + + const [indirectBuffer, indirectMapping] = this.device.createBufferMapped({ + size: indirectArray.byteLength, + usage: GPUBufferUsage.INDIRECT, + }); + + new Int32Array(indirectMapping).set(indirectArray); + indirectBuffer.unmap(); + return indirectBuffer; + } +} + +// Parameterize different sized types + +const typeInfoMap = { + float: { + format: 'float', + size: 4, + validationFunc: 'return valid(v);', + }, + + vec2: { + format: 'float2', + size: 8, + validationFunc: 'return valid(v.x) && valid(v.y);', + }, + + vec3: { + format: 'float3', + size: 12, + validationFunc: 'return valid(v.x) && valid(v.y) && valid(v.z);', + }, + + vec4: { + format: 'float4', + size: 16, + validationFunc: `return valid(v.x) && valid(v.y) && valid(v.z) && valid(v.w) || + v.x == 0 && v.y == 0 && v.z == 0 && (v.w == 0.0 || v.w == 1.0);`, + }, +}; + +g.test('vertexAccess') + .params( + params() + .combine(pbool('indexed')) + .combine(pbool('indirect')) + .expand(p => + poptions( + 'drawCallTestParameter', + p.indexed + ? ['indexCount', 'instanceCount', 'firstIndex', 'baseVertex', 'firstInstance'] + : ['vertexCount', 'instanceCount', 'firstVertex', 'firstInstance'] + ) + ) + .combine(poptions('type', Object.keys(typeInfoMap))) + .combine(poptions('additionalBuffers', [0, 4])) + .combine(pbool('partialLastNumber')) + .combine(pbool('offsetVertexBuffer')) + .combine(poptions('errorScale', [1, 4, 10 ** 2, 10 ** 4, 10 ** 6])) + ) + .fn(async t => { + const p = t.params; + const typeInfo = typeInfoMap[p.type]; + + // Number of vertices to draw + const numVertices = 3; + // Each buffer will be bound to this many attributes (2 would mean 2 attributes per buffer) + const attributesPerBuffer = 2; + // Make an array big enough for the vertices, attributes, and size of each element + const vertexArray = new Float32Array(numVertices * attributesPerBuffer * (typeInfo.size / 4)); + + // Sufficiently unusual values to fill our buffer with to avoid collisions with other tests + const arbitraryValues = [759, 329, 908]; + for (let i = 0; i < vertexArray.length; ++i) { + vertexArray[i] = arbitraryValues[i % arbitraryValues.length]; + } + // A valid value is 0 or one in the buffer + const validValues = [0, ...arbitraryValues]; + + // Instance step mode buffer, vertex step mode buffer + const bufferContents = [vertexArray, vertexArray]; + // Additional buffers (vertex step mode) + for (let i = 0; i < p.additionalBuffers; i++) { + bufferContents.push(vertexArray); + } + + // Mutable draw call + const draw = new DrawCall( + t.device, + bufferContents, + numVertices, + p.partialLastNumber, + p.offsetVertexBuffer + ); + + // Create attributes listing + let layoutStr = ''; + const attributeNames = []; + { + let currAttribute = 0; + for (let i = 0; i < bufferContents.length; i++) { + for (let j = 0; j < attributesPerBuffer; j++) { + layoutStr += `layout(location=${currAttribute}) in ${p.type} a_${currAttribute};\n`; + attributeNames.push(`a_${currAttribute}`); + currAttribute++; + } + } + } + + // Vertex buffer descriptors + const vertexBuffers = []; + { + let currAttribute = 0; + for (let i = 0; i < bufferContents.length; i++) { + vertexBuffers.push({ + arrayStride: attributesPerBuffer * typeInfo.size, + stepMode: i === 0 ? 'instance' : 'vertex', + attributes: Array(attributesPerBuffer) + .fill(0) + .map((_, i) => ({ + shaderLocation: currAttribute++, + offset: i * typeInfo.size, + format: typeInfo.format, + })), + }); + } + } + + // Offset the range checks for gl_VertexIndex in the shader if we use BaseVertex + let vertexIndexOffset = 0; + if (p.drawCallTestParameter === 'baseVertex') { + vertexIndexOffset += p.errorScale; + } + + // Construct pipeline that outputs a red fragment, only if we notice any invalid values + const vertexModule = t.makeShaderModule('vertex', { + glsl: ` + #version 450 + ${layoutStr} + + bool valid(float f) { + return ${validValues.map(v => `f == ${v}`).join(' || ')}; + } + + bool validationFunc(${p.type} v) { + ${typeInfo.validationFunc} + } + + void main() { + bool attributesInBounds = ${attributeNames.map(a => `validationFunc(${a})`).join(' && ')}; + bool indexInBounds = gl_VertexIndex == 0 || (gl_VertexIndex >= ${vertexIndexOffset} && + gl_VertexIndex < ${vertexIndexOffset + numVertices}); + + if (attributesInBounds && (${!p.indexed} || indexInBounds)) { + // Success case, move the vertex out of the viewport + gl_Position = vec4(-1.0, 0.0, 0.0, 1.0); + } else { + // Failure case, move the vertex inside the viewport + gl_Position = vec4(0.0, 0.0, 0.0, 1.0); + } + } + `, + }); + + const fragmentModule = t.makeShaderModule('fragment', { + glsl: ` + #version 450 + precision mediump float; + + layout(location = 0) out vec4 fragColor; + + void main() { + fragColor = vec4(1.0, 0.0, 0.0, 1.0); + } + `, + }); + + // Pipeline setup, texture setup + const colorAttachment = t.device.createTexture({ + format: 'rgba8unorm', + size: { width: 1, height: 1, depth: 1 }, + usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.OUTPUT_ATTACHMENT, + }); + + const colorAttachmentView = colorAttachment.createView(); + + const pipeline = t.device.createRenderPipeline({ + vertexStage: { module: vertexModule, entryPoint: 'main' }, + fragmentStage: { module: fragmentModule, entryPoint: 'main' }, + primitiveTopology: 'point-list', + colorStates: [{ format: 'rgba8unorm', alphaBlend: {}, colorBlend: {} }], + vertexState: { + indexFormat: 'uint16', + vertexBuffers, + }, + }); + + // Offset the draw call parameter we are testing by |errorScale| + draw[p.drawCallTestParameter] += p.errorScale; + + const encoder = t.device.createCommandEncoder(); + const pass = encoder.beginRenderPass({ + colorAttachments: [ + { + attachment: colorAttachmentView, + storeOp: 'store', + loadValue: { r: 0.0, g: 1.0, b: 0.0, a: 1.0 }, + }, + ], + }); + + pass.setPipeline(pipeline); + + // Run the draw variant + draw.insertInto(pass, p.indexed, p.indirect); + + pass.endPass(); + t.device.defaultQueue.submit([encoder.finish()]); + + // Validate we see green instead of red, meaning no fragment ended up on-screen + t.expectSinglePixelIn2DTexture( + colorAttachment, + 'rgba8unorm', + { x: 0, y: 0 }, + { exp: new Uint8Array([0x00, 0xff, 0x00, 0xff]), layout: { mipLevel: 0 } } + ); + }); diff --git a/tests/wpt/webgpu/tests/webgpu/webgpu/util/conversion.js b/tests/wpt/webgpu/tests/webgpu/webgpu/util/conversion.js new file mode 100644 index 00000000000..bdba99cf761 --- /dev/null +++ b/tests/wpt/webgpu/tests/webgpu/webgpu/util/conversion.js @@ -0,0 +1,66 @@ +/** + * AUTO-GENERATED - DO NOT EDIT. Source: https://github.com/gpuweb/cts + **/ import { assert } from '../../common/framework/util/util.js'; +export function floatAsNormalizedInteger(float, bits, signed) { + if (signed) { + assert(float >= -1 && float <= 1); + const max = Math.pow(2, bits - 1) - 1; + return Math.round(float * max); + } else { + assert(float >= 0 && float <= 1); + const max = Math.pow(2, bits) - 1; + return Math.round(float * max); + } +} + +// Does not handle clamping, underflow, overflow, denormalized numbers +export function float32ToFloatBits(n, signBits, exponentBits, fractionBits, bias) { + assert(exponentBits <= 8); + assert(fractionBits <= 23); + assert(Number.isFinite(n)); + + if (n === 0) { + return 0; + } + + if (signBits === 0) { + assert(n >= 0); + } + + const buf = new DataView(new ArrayBuffer(Float32Array.BYTES_PER_ELEMENT)); + buf.setFloat32(0, n, true); + const bits = buf.getUint32(0, true); + // bits (32): seeeeeeeefffffffffffffffffffffff + + const fractionBitsToDiscard = 23 - fractionBits; + + // 0 or 1 + const sign = (bits >> 31) & signBits; + + // >> to remove fraction, & to remove sign, - 127 to remove bias. + const exp = ((bits >> 23) & 0xff) - 127; + + // Convert to the new biased exponent. + const newBiasedExp = bias + exp; + assert(newBiasedExp >= 0 && newBiasedExp < 1 << exponentBits); + + // Mask only the fraction, and discard the lower bits. + const newFraction = (bits & 0x7fffff) >> fractionBitsToDiscard; + return (sign << (exponentBits + fractionBits)) | (newBiasedExp << fractionBits) | newFraction; +} + +export function assertInIntegerRange(n, bits, signed) { + if (signed) { + const min = -Math.pow(2, bits - 1); + const max = Math.pow(2, bits - 1) - 1; + assert(n >= min && n <= max); + } else { + const max = Math.pow(2, bits) - 1; + assert(n >= 0 && n <= max); + } +} + +export function gammaCompress(n) { + n = n <= 0.0031308 ? 12.92 * n : 1.055 * Math.pow(n, 1 / 2.4) - 0.055; + return n < 0 ? 0 : n > 1 ? 1 : n; +} diff --git a/tests/wpt/webgpu/tests/webgpu/webgpu/util/math.js b/tests/wpt/webgpu/tests/webgpu/webgpu/util/math.js new file mode 100644 index 00000000000..a76f1a00158 --- /dev/null +++ b/tests/wpt/webgpu/tests/webgpu/webgpu/util/math.js @@ -0,0 +1,9 @@ +/** + * AUTO-GENERATED - DO NOT EDIT. Source: https://github.com/gpuweb/cts + **/ export function align(n, alignment) { + return Math.ceil(n / alignment) * alignment; +} + +export function isAligned(n, alignment) { + return n === align(n, alignment); +} diff --git a/tests/wpt/webgpu/tests/webgpu/webgpu/util/texture/layout.js b/tests/wpt/webgpu/tests/webgpu/webgpu/util/texture/layout.js new file mode 100644 index 00000000000..cb9a883bd80 --- /dev/null +++ b/tests/wpt/webgpu/tests/webgpu/webgpu/util/texture/layout.js @@ -0,0 +1,133 @@ +/** + * AUTO-GENERATED - DO NOT EDIT. Source: https://github.com/gpuweb/cts + **/ import { assert, unreachable } from '../../../common/framework/util/util.js'; +import { kTextureFormatInfo } from '../../capability_info.js'; +import { align, isAligned } from '../math.js'; + +export const kBytesPerRowAlignment = 256; +export const kBufferCopyAlignment = 4; + +const kDefaultLayoutOptions = { mipLevel: 0, bytesPerRow: undefined, rowsPerImage: undefined }; + +export function getMipSizePassthroughLayers(dimension, size, mipLevel) { + const shiftMinOne = n => Math.max(1, n >> mipLevel); + switch (dimension) { + case '1d': + assert(size[2] === 1); + return [shiftMinOne(size[0]), size[1], size[2]]; + case '2d': + return [shiftMinOne(size[0]), shiftMinOne(size[1]), size[2]]; + case '3d': + return [shiftMinOne(size[0]), shiftMinOne(size[1]), shiftMinOne(size[2])]; + default: + unreachable(); + } +} + +export function getTextureCopyLayout(format, dimension, size, options = kDefaultLayoutOptions) { + const { mipLevel } = options; + let { bytesPerRow, rowsPerImage } = options; + + const mipSize = getMipSizePassthroughLayers(dimension, size, mipLevel); + + const { blockWidth, blockHeight, bytesPerBlock } = kTextureFormatInfo[format]; + assert(!!bytesPerBlock && !!blockWidth && !!blockHeight); + + assert(isAligned(mipSize[0], blockWidth)); + const minBytesPerRow = (mipSize[0] / blockWidth) * bytesPerBlock; + const alignedMinBytesPerRow = align(minBytesPerRow, kBytesPerRowAlignment); + if (bytesPerRow !== undefined) { + assert(bytesPerRow >= alignedMinBytesPerRow); + assert(isAligned(bytesPerRow, kBytesPerRowAlignment)); + } else { + bytesPerRow = alignedMinBytesPerRow; + } + + if (rowsPerImage !== undefined) { + assert(rowsPerImage >= mipSize[1]); + } else { + rowsPerImage = mipSize[1]; + } + + assert(isAligned(rowsPerImage, blockHeight)); + const bytesPerSlice = bytesPerRow * (rowsPerImage / blockHeight); + const sliceSize = + bytesPerRow * (mipSize[1] / blockHeight - 1) + bytesPerBlock * (mipSize[0] / blockWidth); + const byteLength = bytesPerSlice * (mipSize[2] - 1) + sliceSize; + + return { + bytesPerBlock, + byteLength: align(byteLength, kBufferCopyAlignment), + minBytesPerRow, + bytesPerRow, + rowsPerImage, + mipSize, + }; +} + +export function fillTextureDataWithTexelValue( + texelValue, + format, + dimension, + outputBuffer, + size, + options = kDefaultLayoutOptions +) { + const { blockWidth, blockHeight, bytesPerBlock } = kTextureFormatInfo[format]; + assert(!!bytesPerBlock && !!blockWidth && !!blockHeight); + assert(bytesPerBlock === texelValue.byteLength); + + const { byteLength, rowsPerImage, bytesPerRow } = getTextureCopyLayout( + format, + dimension, + size, + options + ); + + assert(byteLength <= outputBuffer.byteLength); + + const mipSize = getMipSizePassthroughLayers(dimension, size, options.mipLevel); + + const texelValueBytes = new Uint8Array(texelValue); + const outputTexelValueBytes = new Uint8Array(outputBuffer); + for (let slice = 0; slice < mipSize[2]; ++slice) { + for (let row = 0; row < mipSize[1]; row += blockHeight) { + for (let col = 0; col < mipSize[0]; col += blockWidth) { + const byteOffset = + slice * rowsPerImage * bytesPerRow + row * bytesPerRow + col * texelValue.byteLength; + outputTexelValueBytes.set(texelValueBytes, byteOffset); + } + } + } +} + +export function createTextureUploadBuffer( + texelValue, + device, + format, + dimension, + size, + options = kDefaultLayoutOptions +) { + const { byteLength, bytesPerRow, rowsPerImage, bytesPerBlock } = getTextureCopyLayout( + format, + dimension, + size, + options + ); + + const [buffer, mapping] = device.createBufferMapped({ + size: byteLength, + usage: GPUBufferUsage.COPY_SRC, + }); + + assert(texelValue.byteLength === bytesPerBlock); + fillTextureDataWithTexelValue(texelValue, format, dimension, mapping, size, options); + buffer.unmap(); + + return { + buffer, + bytesPerRow, + rowsPerImage, + }; +} diff --git a/tests/wpt/webgpu/tests/webgpu/webgpu/util/texture/subresource.js b/tests/wpt/webgpu/tests/webgpu/webgpu/util/texture/subresource.js new file mode 100644 index 00000000000..889fab16e61 --- /dev/null +++ b/tests/wpt/webgpu/tests/webgpu/webgpu/util/texture/subresource.js @@ -0,0 +1,58 @@ +/** + * AUTO-GENERATED - DO NOT EDIT. Source: https://github.com/gpuweb/cts + **/ function _defineProperty(obj, key, value) { + if (key in obj) { + Object.defineProperty(obj, key, { + value: value, + enumerable: true, + configurable: true, + writable: true, + }); + } else { + obj[key] = value; + } + return obj; +} + +function endOfRange(r) { + return 'count' in r ? r.begin + r.count : r.end; +} + +function* rangeAsIterator(r) { + for (let i = r.begin; i < endOfRange(r); ++i) { + yield i; + } +} + +export class SubresourceRange { + constructor(subresources) { + _defineProperty(this, 'mipRange', void 0); + _defineProperty(this, 'sliceRange', void 0); + this.mipRange = { + begin: subresources.mipRange.begin, + end: endOfRange(subresources.mipRange), + }; + + this.sliceRange = { + begin: subresources.sliceRange.begin, + end: endOfRange(subresources.sliceRange), + }; + } + + *each() { + for (let level = this.mipRange.begin; level < this.mipRange.end; ++level) { + for (let slice = this.sliceRange.begin; slice < this.sliceRange.end; ++slice) { + yield { level, slice }; + } + } + } + + *mipLevels() { + for (let level = this.mipRange.begin; level < this.mipRange.end; ++level) { + yield { + level, + slices: rangeAsIterator(this.sliceRange), + }; + } + } +} diff --git a/tests/wpt/webgpu/tests/webgpu/webgpu/util/texture/texelData.js b/tests/wpt/webgpu/tests/webgpu/webgpu/util/texture/texelData.js new file mode 100644 index 00000000000..8a827c47d21 --- /dev/null +++ b/tests/wpt/webgpu/tests/webgpu/webgpu/util/texture/texelData.js @@ -0,0 +1,359 @@ +/** + * AUTO-GENERATED - DO NOT EDIT. Source: https://github.com/gpuweb/cts + **/ function _defineProperty(obj, key, value) { + if (key in obj) { + Object.defineProperty(obj, key, { + value: value, + enumerable: true, + configurable: true, + writable: true, + }); + } else { + obj[key] = value; + } + return obj; +} +import { assert, unreachable } from '../../../common/framework/util/util.js'; +import { kTextureFormatInfo } from '../../capability_info.js'; +import { + assertInIntegerRange, + float32ToFloatBits, + floatAsNormalizedInteger, + gammaCompress, +} from '../conversion.js'; + +export let TexelComponent; +(function (TexelComponent) { + TexelComponent['R'] = 'R'; + TexelComponent['G'] = 'G'; + TexelComponent['B'] = 'B'; + TexelComponent['A'] = 'A'; + TexelComponent['Depth'] = 'Depth'; + TexelComponent['Stencil'] = 'Stencil'; +})(TexelComponent || (TexelComponent = {})); +var TexelWriteType; + +// Function to convert a value into a texel value. It returns the converted value +// and the type of the converted value. For example, conversion may convert: +// - floats to unsigned normalized integers +// - floats to half floats, interpreted as uint16 bits +(function (TexelWriteType) { + TexelWriteType[(TexelWriteType['Sint'] = 0)] = 'Sint'; + TexelWriteType[(TexelWriteType['Uint'] = 1)] = 'Uint'; + TexelWriteType[(TexelWriteType['Float'] = 2)] = 'Float'; +})(TexelWriteType || (TexelWriteType = {})); + +const kR = [TexelComponent.R]; +const kRG = [TexelComponent.R, TexelComponent.G]; +const kRGB = [TexelComponent.R, TexelComponent.G, TexelComponent.B]; +const kRGBA = [TexelComponent.R, TexelComponent.G, TexelComponent.B, TexelComponent.A]; +const kBGRA = [TexelComponent.B, TexelComponent.G, TexelComponent.R, TexelComponent.A]; + +const unorm = bitLength => n => ({ + value: floatAsNormalizedInteger(n, bitLength, false), + type: TexelWriteType.Uint, +}); + +const snorm = bitLength => n => ({ + value: floatAsNormalizedInteger(n, bitLength, true), + type: TexelWriteType.Sint, +}); + +const uint = bitLength => n => ({ + value: (assertInIntegerRange(n, bitLength, false), n), + type: TexelWriteType.Uint, +}); + +const sint = bitLength => n => ({ + value: (assertInIntegerRange(n, bitLength, true), n), + type: TexelWriteType.Sint, +}); + +const unorm2 = { write: unorm(2), bitLength: 2 }; +const unorm8 = { write: unorm(8), bitLength: 8 }; +const unorm10 = { write: unorm(10), bitLength: 10 }; + +const snorm8 = { write: snorm(8), bitLength: 8 }; + +const uint8 = { write: uint(8), bitLength: 8 }; +const uint16 = { write: uint(16), bitLength: 16 }; +const uint32 = { write: uint(32), bitLength: 32 }; + +const sint8 = { write: sint(8), bitLength: 8 }; +const sint16 = { write: sint(16), bitLength: 16 }; +const sint32 = { write: sint(32), bitLength: 32 }; + +const float10 = { + write: n => ({ + value: float32ToFloatBits(n, 0, 5, 5, 15), + type: TexelWriteType.Uint, + }), + + bitLength: 10, +}; + +const float11 = { + write: n => ({ + value: float32ToFloatBits(n, 0, 5, 6, 15), + type: TexelWriteType.Uint, + }), + + bitLength: 11, +}; + +const float16 = { + write: n => ({ + value: float32ToFloatBits(n, 1, 5, 10, 15), + type: TexelWriteType.Uint, + }), + + bitLength: 16, +}; + +const float32 = { + write: n => ({ + value: Math.fround(n), + type: TexelWriteType.Float, + }), + + bitLength: 32, +}; + +const repeatComponents = (componentOrder, perComponentInfo) => { + const componentInfo = componentOrder.reduce((acc, curr) => { + return Object.assign(acc, { + [curr]: perComponentInfo, + }); + }, {}); + + return { + componentOrder, + componentInfo, + }; +}; + +const kRepresentationInfo = { + r8unorm: { ...repeatComponents(kR, unorm8), sRGB: false }, + r8snorm: { ...repeatComponents(kR, snorm8), sRGB: false }, + r8uint: { ...repeatComponents(kR, uint8), sRGB: false }, + r8sint: { ...repeatComponents(kR, sint8), sRGB: false }, + r16uint: { ...repeatComponents(kR, uint16), sRGB: false }, + r16sint: { ...repeatComponents(kR, sint16), sRGB: false }, + r16float: { ...repeatComponents(kR, float16), sRGB: false }, + rg8unorm: { ...repeatComponents(kRG, unorm8), sRGB: false }, + rg8snorm: { ...repeatComponents(kRG, snorm8), sRGB: false }, + rg8uint: { ...repeatComponents(kRG, uint8), sRGB: false }, + rg8sint: { ...repeatComponents(kRG, sint8), sRGB: false }, + r32uint: { ...repeatComponents(kR, uint32), sRGB: false }, + r32sint: { ...repeatComponents(kR, sint32), sRGB: false }, + r32float: { ...repeatComponents(kR, float32), sRGB: false }, + rg16uint: { ...repeatComponents(kRG, uint16), sRGB: false }, + rg16sint: { ...repeatComponents(kRG, sint16), sRGB: false }, + rg16float: { ...repeatComponents(kRG, float16), sRGB: false }, + + rgba8unorm: { ...repeatComponents(kRGBA, unorm8), sRGB: false }, + 'rgba8unorm-srgb': { ...repeatComponents(kRGBA, unorm8), sRGB: true }, + rgba8snorm: { ...repeatComponents(kRGBA, snorm8), sRGB: false }, + rgba8uint: { ...repeatComponents(kRGBA, uint8), sRGB: false }, + rgba8sint: { ...repeatComponents(kRGBA, sint8), sRGB: false }, + bgra8unorm: { ...repeatComponents(kBGRA, unorm8), sRGB: false }, + 'bgra8unorm-srgb': { ...repeatComponents(kBGRA, unorm8), sRGB: true }, + rg32uint: { ...repeatComponents(kRG, uint32), sRGB: false }, + rg32sint: { ...repeatComponents(kRG, sint32), sRGB: false }, + rg32float: { ...repeatComponents(kRG, float32), sRGB: false }, + rgba16uint: { ...repeatComponents(kRGBA, uint16), sRGB: false }, + rgba16sint: { ...repeatComponents(kRGBA, sint16), sRGB: false }, + rgba16float: { ...repeatComponents(kRGBA, float16), sRGB: false }, + rgba32uint: { ...repeatComponents(kRGBA, uint32), sRGB: false }, + rgba32sint: { ...repeatComponents(kRGBA, sint32), sRGB: false }, + rgba32float: { ...repeatComponents(kRGBA, float32), sRGB: false }, + + rgb10a2unorm: { + componentOrder: kRGBA, + componentInfo: { R: unorm10, G: unorm10, B: unorm10, A: unorm2 }, + sRGB: false, + }, + rg11b10float: { + componentOrder: kRGB, + componentInfo: { R: float11, G: float11, B: float10 }, + sRGB: false, + }, + + depth32float: { + componentOrder: [TexelComponent.Depth], + componentInfo: { Depth: float32 }, + sRGB: false, + }, + depth24plus: { + componentOrder: [TexelComponent.Depth], + componentInfo: { Depth: null }, + sRGB: false, + }, + 'depth24plus-stencil8': { + componentOrder: [TexelComponent.Depth, TexelComponent.Stencil], + componentInfo: { Depth: null, Stencil: null }, + sRGB: false, + }, +}; + +class TexelDataRepresentationImpl { + // TODO: Determine endianness of the GPU data? + + constructor(format, componentOrder, componentInfo, sRGB) { + this.format = format; + this.componentOrder = componentOrder; + this.componentInfo = componentInfo; + this.sRGB = sRGB; + _defineProperty(this, 'isGPULittleEndian', true); + } + + totalBitLength() { + return this.componentOrder.reduce((acc, curr) => { + return acc + this.componentInfo[curr].bitLength; + }, 0); + } + + setComponent(data, component, n) { + const componentIndex = this.componentOrder.indexOf(component); + assert(componentIndex !== -1); + const bitOffset = this.componentOrder.slice(0, componentIndex).reduce((acc, curr) => { + const componentInfo = this.componentInfo[curr]; + assert(!!componentInfo); + return acc + componentInfo.bitLength; + }, 0); + + const componentInfo = this.componentInfo[component]; + assert(!!componentInfo); + const { write, bitLength } = componentInfo; + + const { value, type } = write(n); + switch (type) { + case TexelWriteType.Float: { + const byteOffset = Math.floor(bitOffset / 8); + const byteLength = Math.ceil(bitLength / 8); + assert(byteOffset === bitOffset / 8 && byteLength === bitLength / 8); + switch (byteLength) { + case 4: + new DataView(data, byteOffset, byteLength).setFloat32(0, value, this.isGPULittleEndian); + break; + default: + unreachable(); + } + + break; + } + case TexelWriteType.Sint: { + const byteOffset = Math.floor(bitOffset / 8); + const byteLength = Math.ceil(bitLength / 8); + assert(byteOffset === bitOffset / 8 && byteLength === bitLength / 8); + switch (byteLength) { + case 1: + new DataView(data, byteOffset, byteLength).setInt8(0, value); + break; + case 2: + new DataView(data, byteOffset, byteLength).setInt16(0, value, this.isGPULittleEndian); + break; + case 4: + new DataView(data, byteOffset, byteLength).setInt32(0, value, this.isGPULittleEndian); + break; + default: + unreachable(); + } + + break; + } + case TexelWriteType.Uint: { + const byteOffset = Math.floor(bitOffset / 8); + const byteLength = Math.ceil(bitLength / 8); + if (byteOffset === bitOffset / 8 && byteLength === bitLength / 8) { + switch (byteLength) { + case 1: + new DataView(data, byteOffset, byteLength).setUint8(0, value); + break; + case 2: + new DataView(data, byteOffset, byteLength).setUint16( + 0, + value, + this.isGPULittleEndian + ); + + break; + case 4: + new DataView(data, byteOffset, byteLength).setUint32( + 0, + value, + this.isGPULittleEndian + ); + + break; + default: + unreachable(); + } + } else { + // Packed representations are all 32-bit and use Uint as the data type. + // ex.) rg10b11float, rgb10a2unorm + switch (this.totalBitLength()) { + case 32: { + const view = new DataView(data); + const currentValue = view.getUint32(0, this.isGPULittleEndian); + + let mask = 0xffffffff; + const bitsToClearRight = bitOffset; + const bitsToClearLeft = 32 - (bitLength + bitOffset); + + mask = (mask >>> bitsToClearRight) << bitsToClearRight; + mask = (mask << bitsToClearLeft) >>> bitsToClearLeft; + + const newValue = (currentValue & ~mask) | (value << bitOffset); + + view.setUint32(0, newValue, this.isGPULittleEndian); + break; + } + default: + unreachable(); + } + } + break; + } + default: + unreachable(); + } + } + + getBytes(components) { + if (this.sRGB) { + components = Object.assign({}, components); + assert(components.R !== undefined); + assert(components.G !== undefined); + assert(components.B !== undefined); + [components.R, components.G, components.B] = [ + gammaCompress(components.R), + gammaCompress(components.G), + gammaCompress(components.B), + ]; + } + + const bytesPerBlock = kTextureFormatInfo[this.format].bytesPerBlock; + assert(!!bytesPerBlock); + + const data = new ArrayBuffer(bytesPerBlock); + for (const c of this.componentOrder) { + const componentValue = components[c]; + assert(componentValue !== undefined); + this.setComponent(data, c, componentValue); + } + return data; + } +} + +const kRepresentationCache = new Map(); +export function getTexelDataRepresentation(format) { + if (!kRepresentationCache.has(format)) { + const { componentOrder, componentInfo, sRGB } = kRepresentationInfo[format]; + kRepresentationCache.set( + format, + new TexelDataRepresentationImpl(format, componentOrder, componentInfo, sRGB) + ); + } + return kRepresentationCache.get(format); +} diff --git a/tests/wpt/webgpu/tests/webgpu/webgpu/web-platform/canvas/context_creation.spec.js b/tests/wpt/webgpu/tests/webgpu/webgpu/web-platform/canvas/context_creation.spec.js new file mode 100644 index 00000000000..26dc5d8ab67 --- /dev/null +++ b/tests/wpt/webgpu/tests/webgpu/webgpu/web-platform/canvas/context_creation.spec.js @@ -0,0 +1,24 @@ +/** + * AUTO-GENERATED - DO NOT EDIT. Source: https://github.com/gpuweb/cts + **/ export const description = ''; +import { Fixture } from '../../../common/framework/fixture.js'; +import { makeTestGroup } from '../../../common/framework/test_group.js'; + +export const g = makeTestGroup(Fixture); + +g.test('canvas_element_getContext_returns_GPUCanvasContext').fn(async t => { + if (typeof document === 'undefined') { + // Skip if there is no document (Workers, Node) + t.skip('DOM is not available to create canvas element'); + } + + const canvas = document.createElement('canvas'); + canvas.width = 10; + canvas.height = 10; + + // TODO: fix types so these aren't necessary + + const ctx = canvas.getContext('gpupresent'); + + t.expect(ctx instanceof window.GPUCanvasContext); +}); diff --git a/tests/wpt/webgpu/tests/webgpu/webgpu/web-platform/copyImageBitmapToTexture.spec.js b/tests/wpt/webgpu/tests/webgpu/webgpu/web-platform/copyImageBitmapToTexture.spec.js new file mode 100644 index 00000000000..b37e311d280 --- /dev/null +++ b/tests/wpt/webgpu/tests/webgpu/webgpu/web-platform/copyImageBitmapToTexture.spec.js @@ -0,0 +1,372 @@ +/** + * AUTO-GENERATED - DO NOT EDIT. Source: https://github.com/gpuweb/cts + **/ export const description = ` +copy imageBitmap To texture tests. +`; +import { poptions, params } from '../../common/framework/params_builder.js'; +import { makeTestGroup } from '../../common/framework/test_group.js'; +import { unreachable } from '../../common/framework/util/util.js'; +import { kTextureFormatInfo } from '../capability_info.js'; +import { GPUTest } from '../gpu_test.js'; +import { getTexelDataRepresentation } from '../util/texture/texelData.js'; + +function calculateRowPitch(width, bytesPerPixel) { + const bytesPerRow = width * bytesPerPixel; + // Rounds up to a multiple of 256 according to WebGPU requirements. + return (((bytesPerRow - 1) >> 8) + 1) << 8; +} +var Color; + +// Cache for generated pixels. +(function (Color) { + Color[(Color['Red'] = 0)] = 'Red'; + Color[(Color['Green'] = 1)] = 'Green'; + Color[(Color['Blue'] = 2)] = 'Blue'; + Color[(Color['White'] = 3)] = 'White'; + Color[(Color['OpaqueBlack'] = 4)] = 'OpaqueBlack'; + Color[(Color['TransparentBlack'] = 5)] = 'TransparentBlack'; +})(Color || (Color = {})); +const generatedPixelCache = new Map(); + +class F extends GPUTest { + checkCopyImageBitmapResult(src, expected, width, height, bytesPerPixel) { + const exp = new Uint8Array(expected.buffer, expected.byteOffset, expected.byteLength); + const rowPitch = calculateRowPitch(width, bytesPerPixel); + const dst = this.createCopyForMapRead(src, 0, rowPitch * height); + + this.eventualAsyncExpectation(async niceStack => { + const actual = new Uint8Array(await dst.mapReadAsync()); + const check = this.checkBufferWithRowPitch( + actual, + exp, + width, + height, + rowPitch, + bytesPerPixel + ); + + if (check !== undefined) { + niceStack.message = check; + this.rec.expectationFailed(niceStack); + } + dst.destroy(); + }); + } + + checkBufferWithRowPitch(actual, exp, width, height, rowPitch, bytesPerPixel) { + const failedByteIndices = []; + const failedByteExpectedValues = []; + const failedByteActualValues = []; + iLoop: for (let i = 0; i < height; ++i) { + const bytesPerRow = width * bytesPerPixel; + for (let j = 0; j < bytesPerRow; ++j) { + const indexExp = j + i * bytesPerRow; + const indexActual = j + rowPitch * i; + if (actual[indexActual] !== exp[indexExp]) { + if (failedByteIndices.length >= 4) { + failedByteIndices.push('...'); + failedByteExpectedValues.push('...'); + failedByteActualValues.push('...'); + break iLoop; + } + failedByteIndices.push(`(${i},${j})`); + failedByteExpectedValues.push(exp[indexExp].toString()); + failedByteActualValues.push(actual[indexActual].toString()); + } + } + } + if (failedByteIndices.length > 0) { + return `at [${failedByteIndices.join(', ')}], \ +expected [${failedByteExpectedValues.join(', ')}], \ +got [${failedByteActualValues.join(', ')}]`; + } + return undefined; + } + + doTestAndCheckResult( + imageBitmapCopyView, + dstTextureCopyView, + copySize, + bytesPerPixel, + expectedData + ) { + this.device.defaultQueue.copyImageBitmapToTexture( + imageBitmapCopyView, + dstTextureCopyView, + copySize + ); + + const imageBitmap = imageBitmapCopyView.imageBitmap; + const dstTexture = dstTextureCopyView.texture; + + const bytesPerRow = calculateRowPitch(imageBitmap.width, bytesPerPixel); + const testBuffer = this.device.createBuffer({ + size: bytesPerRow * imageBitmap.height, + usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST, + }); + + const encoder = this.device.createCommandEncoder(); + + encoder.copyTextureToBuffer( + { texture: dstTexture, mipLevel: 0, origin: { x: 0, y: 0, z: 0 } }, + { buffer: testBuffer, bytesPerRow }, + { width: imageBitmap.width, height: imageBitmap.height, depth: 1 } + ); + + this.device.defaultQueue.submit([encoder.finish()]); + + this.checkCopyImageBitmapResult( + testBuffer, + expectedData, + imageBitmap.width, + imageBitmap.height, + bytesPerPixel + ); + } + + generatePixel(color, format) { + var _generatedPixelCache$, _generatedPixelCache$3; + if (!generatedPixelCache.get(format)) { + generatedPixelCache.set(format, new Map()); + } + + // None of the dst texture format is 'uint' or 'sint', so we can always use float value. + if ( + !((_generatedPixelCache$ = generatedPixelCache.get(format)) === null || + _generatedPixelCache$ === void 0 + ? void 0 + : _generatedPixelCache$.has(color)) + ) { + var _generatedPixelCache$2; + let pixels; + switch (color) { + case Color.Red: + pixels = new Uint8Array( + getTexelDataRepresentation(format).getBytes({ R: 1.0, G: 0, B: 0, A: 1.0 }) + ); + + break; + case Color.Green: + pixels = new Uint8Array( + getTexelDataRepresentation(format).getBytes({ R: 0, G: 1.0, B: 0, A: 1.0 }) + ); + + break; + case Color.Blue: + pixels = new Uint8Array( + getTexelDataRepresentation(format).getBytes({ R: 0, G: 0, B: 1.0, A: 1.0 }) + ); + + break; + case Color.White: + pixels = new Uint8Array( + getTexelDataRepresentation(format).getBytes({ R: 0, G: 0, B: 0, A: 1.0 }) + ); + + break; + case Color.OpaqueBlack: + pixels = new Uint8Array( + getTexelDataRepresentation(format).getBytes({ R: 1.0, G: 1.0, B: 1.0, A: 1.0 }) + ); + + break; + case Color.TransparentBlack: + pixels = new Uint8Array( + getTexelDataRepresentation(format).getBytes({ R: 1.0, G: 1.0, B: 1.0, A: 0 }) + ); + + break; + default: + unreachable(); + } + + (_generatedPixelCache$2 = generatedPixelCache.get(format)) === null || + _generatedPixelCache$2 === void 0 + ? void 0 + : _generatedPixelCache$2.set(color, pixels); + } + + return (_generatedPixelCache$3 = generatedPixelCache.get(format)) === null || + _generatedPixelCache$3 === void 0 + ? void 0 + : _generatedPixelCache$3.get(color); + } +} + +export const g = makeTestGroup(F); + +g.test('from_ImageData') + .params( + params() + .combine(poptions('width', [1, 2, 4, 15, 255, 256])) + .combine(poptions('height', [1, 2, 4, 15, 255, 256])) + .combine(poptions('alpha', ['none', 'premultiply'])) + .combine(poptions('orientation', ['none', 'flipY'])) + .combine( + poptions('dstColorFormat', [ + 'rgba8unorm', + 'bgra8unorm', + 'rgba8unorm-srgb', + 'bgra8unorm-srgb', + 'rgb10a2unorm', + 'rgba16float', + 'rgba32float', + 'rg8unorm', + 'rg16float', + ]) + ) + ) + .fn(async t => { + const { width, height, alpha, orientation, dstColorFormat } = t.params; + + const srcBytesPerPixel = kTextureFormatInfo['rgba8unorm'].bytesPerBlock; + + // Generate input contents by iterating 'Color' enum + const imagePixels = new Uint8ClampedArray(srcBytesPerPixel * width * height); + const startPixel = Color.Red; + for (let i = 0, currentPixel = startPixel; i < width * height; ++i) { + const pixels = t.generatePixel(currentPixel, 'rgba8unorm'); + if (currentPixel === Color.TransparentBlack) { + currentPixel = Color.Red; + } else { + ++currentPixel; + } + for (let j = 0; j < srcBytesPerPixel; ++j) { + imagePixels[i * srcBytesPerPixel + j] = pixels[j]; + } + } + + // Generate correct expected values + const imageData = new ImageData(imagePixels, width, height); + + const imageBitmap = await createImageBitmap(imageData, { + premultiplyAlpha: alpha, + imageOrientation: orientation, + }); + + const dst = t.device.createTexture({ + size: { + width: imageBitmap.width, + height: imageBitmap.height, + depth: 1, + }, + + format: dstColorFormat, + usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, + }); + + // Construct expected value for different dst color format + const dstBytesPerPixel = kTextureFormatInfo[dstColorFormat].bytesPerBlock; + const dstPixels = new Uint8ClampedArray(dstBytesPerPixel * width * height); + let expectedPixels = new Uint8ClampedArray(dstBytesPerPixel * width * height); + for (let i = 0, currentPixel = startPixel; i < width * height; ++i) { + const pixels = t.generatePixel(currentPixel, dstColorFormat); + for (let j = 0; j < dstBytesPerPixel; ++j) { + // All pixels are 0 due to premultiply alpha + if (alpha === 'premultiply' && currentPixel === Color.TransparentBlack) { + dstPixels[i * dstBytesPerPixel + j] = 0; + } else { + dstPixels[i * dstBytesPerPixel + j] = pixels[j]; + } + } + + if (currentPixel === Color.TransparentBlack) { + currentPixel = Color.Red; + } else { + ++currentPixel; + } + } + + if (orientation === 'flipY') { + for (let i = 0; i < height; ++i) { + for (let j = 0; j < width * dstBytesPerPixel; ++j) { + const posImagePixel = (height - i - 1) * width * dstBytesPerPixel + j; + const posExpectedValue = i * width * dstBytesPerPixel + j; + expectedPixels[posExpectedValue] = dstPixels[posImagePixel]; + } + } + } else { + expectedPixels = dstPixels; + } + + t.doTestAndCheckResult( + { imageBitmap, origin: { x: 0, y: 0 } }, + { texture: dst }, + { width: imageBitmap.width, height: imageBitmap.height, depth: 1 }, + dstBytesPerPixel, + expectedPixels + ); + }); + +g.test('from_canvas') + .params( + params() + .combine(poptions('width', [1, 2, 4, 15, 255, 256])) + .combine(poptions('height', [1, 2, 4, 15, 255, 256])) + ) + .fn(async t => { + const { width, height } = t.params; + + // CTS sometimes runs on worker threads, where document is not available. + // In this case, OffscreenCanvas can be used instead of . + // But some browsers don't support OffscreenCanvas, and some don't + // support '2d' contexts on OffscreenCanvas. + // In this situation, the case will be skipped. + let imageCanvas; + if (typeof document !== 'undefined') { + imageCanvas = document.createElement('canvas'); + imageCanvas.width = width; + imageCanvas.height = height; + } else if (typeof OffscreenCanvas === 'undefined') { + t.skip('OffscreenCanvas is not supported'); + return; + } else { + imageCanvas = new OffscreenCanvas(width, height); + } + const imageCanvasContext = imageCanvas.getContext('2d'); + if (imageCanvasContext === null) { + t.skip('OffscreenCanvas "2d" context not available'); + return; + } + + // The texture format is rgba8unorm, so the bytes per pixel is 4. + const bytesPerPixel = 4; + + // Generate original data. + const imagePixels = new Uint8ClampedArray(bytesPerPixel * width * height); + for (let i = 0; i < width * height * bytesPerPixel; ++i) { + imagePixels[i] = i % 4 === 3 ? 255 : i % 256; + } + + const imageData = new ImageData(imagePixels, width, height); + imageCanvasContext.putImageData(imageData, 0, 0); + + const imageBitmap = await createImageBitmap(imageCanvas); + + const dst = t.device.createTexture({ + size: { + width: imageBitmap.width, + height: imageBitmap.height, + depth: 1, + }, + + format: 'rgba8unorm', + usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, + }); + + // This will get origin data and even it has premultiplied-alpha + const expectedData = imageCanvasContext.getImageData( + 0, + 0, + imageBitmap.width, + imageBitmap.height + ).data; + + t.doTestAndCheckResult( + { imageBitmap, origin: { x: 0, y: 0 } }, + { texture: dst }, + { width: imageBitmap.width, height: imageBitmap.height, depth: 1 }, + bytesPerPixel, + expectedData + ); + }); diff --git a/tests/wpt/webgpu/tests/webgpu/webgpu/web-platform/reftests/canvas_clear.html b/tests/wpt/webgpu/tests/webgpu/webgpu/web-platform/reftests/canvas_clear.html new file mode 100644 index 00000000000..86a3da939db --- /dev/null +++ b/tests/wpt/webgpu/tests/webgpu/webgpu/web-platform/reftests/canvas_clear.html @@ -0,0 +1,10 @@ + + WebGPU canvas_clear + + + + + + + + diff --git a/tests/wpt/webgpu/tests/webgpu/webgpu/web-platform/reftests/canvas_clear.js b/tests/wpt/webgpu/tests/webgpu/webgpu/web-platform/reftests/canvas_clear.js new file mode 100644 index 00000000000..a9149f03942 --- /dev/null +++ b/tests/wpt/webgpu/tests/webgpu/webgpu/web-platform/reftests/canvas_clear.js @@ -0,0 +1,29 @@ +/** + * AUTO-GENERATED - DO NOT EDIT. Source: https://github.com/gpuweb/cts + **/ import { runRefTest } from './gpu_ref_test.js'; +runRefTest(async t => { + const canvas = document.getElementById('gpucanvas'); + + const ctx = canvas.getContext('gpupresent'); + const swapChain = ctx.configureSwapChain({ + device: t.device, + format: 'bgra8unorm', + }); + + const colorAttachment = swapChain.getCurrentTexture(); + const colorAttachmentView = colorAttachment.createView(); + + const encoder = t.device.createCommandEncoder(); + const pass = encoder.beginRenderPass({ + colorAttachments: [ + { + attachment: colorAttachmentView, + loadValue: { r: 0.0, g: 1.0, b: 0.0, a: 1.0 }, + storeOp: 'store', + }, + ], + }); + + pass.endPass(); + t.device.defaultQueue.submit([encoder.finish()]); +}); diff --git a/tests/wpt/webgpu/tests/webgpu/webgpu/web-platform/reftests/canvas_complex.js b/tests/wpt/webgpu/tests/webgpu/webgpu/web-platform/reftests/canvas_complex.js new file mode 100644 index 00000000000..e1aa3a25f88 --- /dev/null +++ b/tests/wpt/webgpu/tests/webgpu/webgpu/web-platform/reftests/canvas_complex.js @@ -0,0 +1,78 @@ +/** + * AUTO-GENERATED - DO NOT EDIT. Source: https://github.com/gpuweb/cts + **/ import { unreachable } from '../../../common/framework/util/util.js'; +import { runRefTest } from './gpu_ref_test.js'; + +// element from html page + +export function run(format) { + runRefTest(async t => { + const ctx = cvs.getContext('gpupresent'); + + switch (format) { + case 'bgra8unorm': + case 'rgba16float': + break; + default: + unreachable(); + } + + const swapChain = ctx.configureSwapChain({ + device: t.device, + format, + usage: GPUTextureUsage.COPY_DST, + }); + + const rows = 2; + const bytesPerRow = 256; + const [buffer, mapping] = t.device.createBufferMapped({ + size: rows * bytesPerRow, + usage: GPUBufferUsage.COPY_SRC, + }); + + switch (format) { + case 'bgra8unorm': + { + const data = new Uint8Array(mapping); + data.set(new Uint8Array([0x00, 0x00, 0x7f, 0xff]), 0); // red + data.set(new Uint8Array([0x00, 0x7f, 0x00, 0xff]), 4); // green + data.set(new Uint8Array([0x7f, 0x00, 0x00, 0xff]), 256 + 0); // blue + data.set(new Uint8Array([0x00, 0x7f, 0x7f, 0xff]), 256 + 4); // yellow + } + break; + case 'rgba16float': + { + // Untested! + const zero = 0x0000; + const half = 0x3800; + const one = 0x3c00; + const data = new DataView(mapping); + data.setUint16(0x000, half, false); // red + data.setUint16(0x002, zero, false); + data.setUint16(0x004, zero, false); + data.setUint16(0x008, one, false); + data.setUint16(0x010, zero, false); // green + data.setUint16(0x020, half, false); + data.setUint16(0x040, zero, false); + data.setUint16(0x080, one, false); + data.setUint16(0x100, zero, false); // blue + data.setUint16(0x102, zero, false); + data.setUint16(0x104, half, false); + data.setUint16(0x108, one, false); + data.setUint16(0x110, half, false); // yellow + data.setUint16(0x120, half, false); + data.setUint16(0x140, zero, false); + data.setUint16(0x180, one, false); + } + break; + } + + buffer.unmap(); + + const texture = swapChain.getCurrentTexture(); + + const encoder = t.device.createCommandEncoder(); + encoder.copyBufferToTexture({ buffer, bytesPerRow }, { texture }, [2, 2, 1]); + t.device.defaultQueue.submit([encoder.finish()]); + }); +} diff --git a/tests/wpt/webgpu/tests/webgpu/webgpu/web-platform/reftests/canvas_complex_bgra8unorm.html b/tests/wpt/webgpu/tests/webgpu/webgpu/web-platform/reftests/canvas_complex_bgra8unorm.html new file mode 100644 index 00000000000..1310543648e --- /dev/null +++ b/tests/wpt/webgpu/tests/webgpu/webgpu/web-platform/reftests/canvas_complex_bgra8unorm.html @@ -0,0 +1,18 @@ + + WebGPU canvas_complex_bgra8unorm + + + + + + + + + diff --git a/tests/wpt/webgpu/tests/webgpu/webgpu/web-platform/reftests/gpu_ref_test.js b/tests/wpt/webgpu/tests/webgpu/webgpu/web-platform/reftests/gpu_ref_test.js new file mode 100644 index 00000000000..dd58b543b01 --- /dev/null +++ b/tests/wpt/webgpu/tests/webgpu/webgpu/web-platform/reftests/gpu_ref_test.js @@ -0,0 +1,18 @@ +/** + * AUTO-GENERATED - DO NOT EDIT. Source: https://github.com/gpuweb/cts + **/ import { assert } from '../../../common/framework/util/util.js'; + +export async function runRefTest(fn) { + assert( + typeof navigator !== 'undefined' && navigator.gpu !== undefined, + 'No WebGPU implementation found' + ); + + const adapter = await navigator.gpu.requestAdapter(); + const device = await adapter.requestDevice(); + const queue = device.defaultQueue; + + await fn({ device, queue }); + + takeScreenshotDelayed(50); +} diff --git a/tests/wpt/webgpu/tests/webgpu/webgpu/web-platform/reftests/ref/canvas_clear-ref.html b/tests/wpt/webgpu/tests/webgpu/webgpu/web-platform/reftests/ref/canvas_clear-ref.html new file mode 100644 index 00000000000..2e078118627 --- /dev/null +++ b/tests/wpt/webgpu/tests/webgpu/webgpu/web-platform/reftests/ref/canvas_clear-ref.html @@ -0,0 +1,12 @@ + + WebGPU canvas_clear (ref) + + + + + diff --git a/tests/wpt/webgpu/tests/webgpu/webgpu/web-platform/reftests/ref/canvas_complex-ref.html b/tests/wpt/webgpu/tests/webgpu/webgpu/web-platform/reftests/ref/canvas_complex-ref.html new file mode 100644 index 00000000000..3d5b3b3376d --- /dev/null +++ b/tests/wpt/webgpu/tests/webgpu/webgpu/web-platform/reftests/ref/canvas_complex-ref.html @@ -0,0 +1,17 @@ + + WebGPU canvas_complex (ref) + + + + + From 32a4104f4a06a429c86c67f512c92769dd157b05 Mon Sep 17 00:00:00 2001 From: Kunal Mohan Date: Sat, 25 Jul 2020 17:47:09 +0530 Subject: [PATCH 2/6] changes made for cts to work --- python/tidy/servo_tidy/tidy.py | 2 +- tests/wpt/aliases | 1 + tests/wpt/include.ini | 2 + tests/wpt/webgpu/meta/MANIFEST.json | 16 +++- tests/wpt/webgpu/meta/__dir__.ini | 1 + tests/wpt/webgpu/tests/webgpu/cts.html | 2 +- .../third_party/glslang_js/lib/glslang.js | 78 ++++++++++++++++++ .../third_party/glslang_js/lib/glslang.wasm | Bin 0 -> 943680 bytes 8 files changed, 99 insertions(+), 3 deletions(-) create mode 100644 tests/wpt/webgpu/meta/__dir__.ini create mode 100644 tests/wpt/webgpu/tests/webgpu/third_party/glslang_js/lib/glslang.js create mode 100644 tests/wpt/webgpu/tests/webgpu/third_party/glslang_js/lib/glslang.wasm diff --git a/python/tidy/servo_tidy/tidy.py b/python/tidy/servo_tidy/tidy.py index 163fd99e867..1b57f9c59de 100644 --- a/python/tidy/servo_tidy/tidy.py +++ b/python/tidy/servo_tidy/tidy.py @@ -515,7 +515,7 @@ def check_manifest_dirs(config_file, print_text=True): p = parser.parse(lines) paths = rec_parse(wpt_path("web-platform-tests"), p) for idx, path in enumerate(paths): - if '_mozilla' in path or '_webgl' in path: + if '_mozilla' in path or '_webgl' in path or '_webgpu' in path: continue if not os.path.isdir(path): yield(config_file, idx + 1, "Path in manifest was not found: {}".format(path)) diff --git a/tests/wpt/aliases b/tests/wpt/aliases index 47801128b33..ac18f371539 100644 --- a/tests/wpt/aliases +++ b/tests/wpt/aliases @@ -1,3 +1,4 @@ /,./ /_mozilla/,../mozilla/tests /_webgl/,../webgl/tests +/_webgpu/,../webgpu/tests diff --git a/tests/wpt/include.ini b/tests/wpt/include.ini index 340c10ad166..27efd8798b9 100644 --- a/tests/wpt/include.ini +++ b/tests/wpt/include.ini @@ -5,6 +5,8 @@ skip: true skip: false [_webgl] skip: false +[_webgpu] + skip: false [cookies] skip: false [samesite] diff --git a/tests/wpt/webgpu/meta/MANIFEST.json b/tests/wpt/webgpu/meta/MANIFEST.json index d757e39a0c0..5fe88f43059 100644 --- a/tests/wpt/webgpu/meta/MANIFEST.json +++ b/tests/wpt/webgpu/meta/MANIFEST.json @@ -186,6 +186,20 @@ ] } }, + "third_party": { + "glslang_js": { + "lib": { + "glslang.js": [ + "21bd32eafa285c95c87c14056e1e0f253549dedd", + [] + ], + "glslang.wasm": [ + "d951d65e063a930ad0d841848367f7b8cc6b2703", + [] + ] + } + } + }, "webgpu": { "api": { "operation": { @@ -475,7 +489,7 @@ "testharness": { "webgpu": { "cts.html": [ - "ea93cd81ce10e23a272a10bcbc0914644ef39cc9", + "40941fb9520652e95c3f356b05b73310b3ebdddb", [ "webgpu/cts.html?q=webgpu:api,operation,buffers,create_mapped:*", {} diff --git a/tests/wpt/webgpu/meta/__dir__.ini b/tests/wpt/webgpu/meta/__dir__.ini new file mode 100644 index 00000000000..bb05019d943 --- /dev/null +++ b/tests/wpt/webgpu/meta/__dir__.ini @@ -0,0 +1 @@ +prefs: ["dom.webgpu.enabled:true"] diff --git a/tests/wpt/webgpu/tests/webgpu/cts.html b/tests/wpt/webgpu/tests/webgpu/cts.html index ea93cd81ce1..40941fb9520 100644 --- a/tests/wpt/webgpu/tests/webgpu/cts.html +++ b/tests/wpt/webgpu/tests/webgpu/cts.html @@ -26,7 +26,7 @@ - + diff --git a/tests/wpt/webgpu/tests/webgpu/third_party/glslang_js/lib/glslang.js b/tests/wpt/webgpu/tests/webgpu/third_party/glslang_js/lib/glslang.js new file mode 100644 index 00000000000..21bd32eafa2 --- /dev/null +++ b/tests/wpt/webgpu/tests/webgpu/third_party/glslang_js/lib/glslang.js @@ -0,0 +1,78 @@ + +var Module = (function() { + var _scriptDir = typeof document !== 'undefined' && document.currentScript ? document.currentScript.src : undefined; + + return ( +function(Module) { + Module = Module || {}; + +var c;c||(c=typeof Module !== 'undefined' ? Module : {}); +c.compileGLSLZeroCopy=function(a,b,d,e){d=!!d;switch(b){case "vertex":var g=0;break;case "fragment":g=4;break;case "compute":g=5;break;default:throw Error("shader_stage must be 'vertex', 'fragment', or 'compute'.");}switch(e||"1.0"){case "1.0":var f=65536;break;case "1.1":f=65792;break;case "1.2":f=66048;break;case "1.3":f=66304;break;case "1.4":f=66560;break;case "1.5":f=66816;break;default:throw Error("spirv_version must be '1.0' ~ '1.5'.");}e=c._malloc(4);b=c._malloc(4);var h=aa([a,g,d,f,e,b]); +d=k(e);a=k(b);c._free(e);c._free(b);if(0===h)throw Error("GLSL compilation failed");e={};d/=4;e.data=c.HEAPU32.subarray(d,d+a);e.free=function(){c._destroy_output_buffer(h)};return e};c.compileGLSL=function(a,b,d,e){a=c.compileGLSLZeroCopy(a,b,d,e);b=a.data.slice();a.free();return b};var p={},q;for(q in c)c.hasOwnProperty(q)&&(p[q]=c[q]);var r="./this.program",t=!1,u=!1;t="object"===typeof window;u="function"===typeof importScripts;var v="",w; +if(t||u)u?v=self.location.href:document.currentScript&&(v=document.currentScript.src),_scriptDir&&(v=_scriptDir),0!==v.indexOf("blob:")?v=v.substr(0,v.lastIndexOf("/")+1):v="",u&&(w=function(a){var b=new XMLHttpRequest;b.open("GET",a,!1);b.responseType="arraybuffer";b.send(null);return new Uint8Array(b.response)});var x=c.print||console.log.bind(console),y=c.printErr||console.warn.bind(console);for(q in p)p.hasOwnProperty(q)&&(c[q]=p[q]);p=null;c.thisProgram&&(r=c.thisProgram);var A; +c.wasmBinary&&(A=c.wasmBinary);"object"!==typeof WebAssembly&&y("no native wasm support detected");function k(a){var b="i32";"*"===b.charAt(b.length-1)&&(b="i32");switch(b){case "i1":return B[a>>0];case "i8":return B[a>>0];case "i16":return ba[a>>1];case "i32":return C[a>>2];case "i64":return C[a>>2];case "float":return ca[a>>2];case "double":return da[a>>3];default:D("invalid type for getValue: "+b)}return null}var E,ea=new WebAssembly.Table({initial:859,maximum:859,element:"anyfunc"}),fa=!1; +function ha(){var a=c._convert_glsl_to_spirv;a||D("Assertion failed: Cannot call unknown function convert_glsl_to_spirv, make sure it is exported");return a} +function aa(a){var b="string number boolean number number number".split(" "),d={string:function(a){var b=0;if(null!==a&&void 0!==a&&0!==a){var d=(a.length<<2)+1;b=G(d);ia(a,H,b,d)}return b},array:function(a){var b=G(a.length);B.set(a,b);return b}},e=ha(),g=[],f=0;if(a)for(var h=0;h=e);)++d;if(16g?e+=String.fromCharCode(g):(g-=65536,e+=String.fromCharCode(55296|g>>10,56320|g&1023))}}else e+=String.fromCharCode(g)}return e} +function ia(a,b,d,e){if(0=f){var h=a.charCodeAt(++g);f=65536+((f&1023)<<10)|h&1023}if(127>=f){if(d>=e)break;b[d++]=f}else{if(2047>=f){if(d+1>=e)break;b[d++]=192|f>>6}else{if(65535>=f){if(d+2>=e)break;b[d++]=224|f>>12}else{if(d+3>=e)break;b[d++]=240|f>>18;b[d++]=128|f>>12&63}b[d++]=128|f>>6&63}b[d++]=128|f&63}}b[d]=0}}"undefined"!==typeof TextDecoder&&new TextDecoder("utf-16le");var J,B,H,ba,C,ca,da; +function ma(a){J=a;c.HEAP8=B=new Int8Array(a);c.HEAP16=ba=new Int16Array(a);c.HEAP32=C=new Int32Array(a);c.HEAPU8=H=new Uint8Array(a);c.HEAPU16=new Uint16Array(a);c.HEAPU32=new Uint32Array(a);c.HEAPF32=ca=new Float32Array(a);c.HEAPF64=da=new Float64Array(a)}var na=c.TOTAL_MEMORY||16777216;c.wasmMemory?E=c.wasmMemory:E=new WebAssembly.Memory({initial:na/65536});E&&(J=E.buffer);na=J.byteLength;ma(J);C[84916]=5582704; +function K(a){for(;0>2]}var Q={},Ba={}; +function Ca(){if(!R){var a={USER:"web_user",LOGNAME:"web_user",PATH:"/",PWD:"/",HOME:"/home/web_user",LANG:("object"===typeof navigator&&navigator.languages&&navigator.languages[0]||"C").replace("-","_")+".UTF-8",_:r},b;for(b in Ba)a[b]=Ba[b];var d=[];for(b in a)d.push(b+"="+a[b]);R=d}return R}var R;function S(a){return 0===a%4&&(0!==a%100||0===a%400)}function T(a,b){for(var d=0,e=0;e<=b;d+=a[e++]);return d}var U=[31,29,31,30,31,30,31,31,30,31,30,31],W=[31,28,31,30,31,30,31,31,30,31,30,31]; +function X(a,b){for(a=new Date(a.getTime());0e-a.getDate())b-=e-a.getDate()+1,a.setDate(1),11>d?a.setMonth(d+1):(a.setMonth(0),a.setFullYear(a.getFullYear()+1));else{a.setDate(a.getDate()+b);break}}return a} +function Da(a,b,d,e){function g(a,b,d){for(a="number"===typeof a?a.toString():a||"";a.lengtha?-1:0=h(n(new Date(a.getFullYear(),0,4)),a)?0>=h(b,a)?a.getFullYear()+1:a.getFullYear():a.getFullYear()-1}var m=C[e+40>>2];e={N:C[e>>2],M:C[e+4>>2],D:C[e+8>>2],C:C[e+12>>2],B:C[e+16>>2],A:C[e+20>>2],F:C[e+24>>2],G:C[e+28>>2],X:C[e+32>>2],L:C[e+36>>2],O:m?m?I(H,m,void 0): +"":""};d=d?I(H,d,void 0):"";m={"%c":"%a %b %d %H:%M:%S %Y","%D":"%m/%d/%y","%F":"%Y-%m-%d","%h":"%b","%r":"%I:%M:%S %p","%R":"%H:%M","%T":"%H:%M:%S","%x":"%m/%d/%y","%X":"%H:%M:%S","%Ec":"%c","%EC":"%C","%Ex":"%m/%d/%y","%EX":"%H:%M:%S","%Ey":"%y","%EY":"%Y","%Od":"%d","%Oe":"%e","%OH":"%H","%OI":"%I","%Om":"%m","%OM":"%M","%OS":"%S","%Ou":"%u","%OU":"%U","%OV":"%V","%Ow":"%w","%OW":"%W","%Oy":"%y"};for(var l in m)d=d.replace(new RegExp(l,"g"),m[l]);var F="Sunday Monday Tuesday Wednesday Thursday Friday Saturday".split(" "), +va="January February March April May June July August September October November December".split(" ");m={"%a":function(a){return F[a.F].substring(0,3)},"%A":function(a){return F[a.F]},"%b":function(a){return va[a.B].substring(0,3)},"%B":function(a){return va[a.B]},"%C":function(a){return f((a.A+1900)/100|0,2)},"%d":function(a){return f(a.C,2)},"%e":function(a){return g(a.C,2," ")},"%g":function(a){return z(a).toString().substring(2)},"%G":function(a){return z(a)},"%H":function(a){return f(a.D,2)}, +"%I":function(a){a=a.D;0==a?a=12:12a.D?"AM":"PM"},"%S":function(a){return f(a.N,2)},"%t":function(){return"\t"},"%u":function(a){return a.F||7},"%U":function(a){var b=new Date(a.A+1900,0,1),d=0===b.getDay()?b:X(b,7-b.getDay());a=new Date(a.A+1900,a.B,a.C);return 0>h(d,a)?f(Math.ceil((31- +d.getDate()+(T(S(a.getFullYear())?U:W,a.getMonth()-1)-31)+a.getDate())/7),2):0===h(d,b)?"01":"00"},"%V":function(a){var b=n(new Date(a.A+1900,0,4)),d=n(new Date(a.A+1901,0,4)),e=X(new Date(a.A+1900,0,1),a.G);return 0>h(e,b)?"53":0>=h(d,e)?"01":f(Math.ceil((b.getFullYear()h(d,a)?f(Math.ceil((31- +d.getDate()+(T(S(a.getFullYear())?U:W,a.getMonth()-1)-31)+a.getDate())/7),2):0===h(d,b)?"01":"00"},"%y":function(a){return(a.A+1900).toString().substring(2)},"%Y":function(a){return a.A+1900},"%z":function(a){a=a.L;var b=0<=a;a=Math.abs(a)/60;return(b?"+":"-")+String("0000"+(a/60*100+a%60)).slice(-4)},"%Z":function(a){return a.O},"%%":function(){return"%"}};for(l in m)0<=d.indexOf(l)&&(d=d.replace(new RegExp(l,"g"),m[l](e)));l=Ea(d);if(l.length>b)return 0;B.set(l,a);return l.length-1} +function Ea(a){for(var b=0,d=0;d=e&&(e=65536+((e&1023)<<10)|a.charCodeAt(++d)&1023);127>=e?++b:b=2047>=e?b+2:65535>=e?b+3:b+4}b=Array(b+1);ia(a,b,0,b.length);return b} +var Ga={f:function(){},c:function(){c.___errno_location&&(C[c.___errno_location()>>2]=63);return-1},n:function(a,b){P=b;try{var d=Aa();var e=Aa();if(-1===d||0===e)var g=-28;else{var f=Q.K[d];if(f&&e===f.U){var h=(void 0).T(f.S);Q.R(d,h,e,f.flags,f.offset);(void 0).W(h);Q.K[d]=null;f.P&&Fa(f.V)}g=0}return g}catch(n){return D(n),-n.I}},a:function(){},b:function(){D()},k:function(a,b,d){H.set(H.subarray(b,b+d),a)},l:function(a){var b=B.length;if(2147418112=d;d*=2){var e=b*(1+ +.2/d);e=Math.min(e,a+100663296);e=Math.max(16777216,a,e);0>16);ma(E.buffer);var g=1;break a}catch(f){}g=void 0}if(g)return!0}return!1},d:function(a,b){var d=0;Ca().forEach(function(e,g){var f=b+d;g=C[a+4*g>>2]=f;for(f=0;f>0]=e.charCodeAt(f);B[g>>0]=0;d+=e.length+1});return 0},e:function(a,b){var d=Ca();C[a>>2]=d.length;var e=0;d.forEach(function(a){e+=a.length+1});C[b>>2]=e;return 0},h:function(){return 0}, +j:function(){return 0},g:function(a,b,d,e){try{for(var g=0,f=0;f>2],n=C[b+(8*f+4)>>2],z=0;z>2]=g;return 0}catch(F){return D(F),F.I}},memory:E,o:function(){},i:function(){},m:function(a,b,d,e){return Da(a,b,d,e)},table:ea},Ha=function(){function a(a){c.asm=a.exports;L--;c.monitorRunDependencies&&c.monitorRunDependencies(L);0==L&&(null!==M&&(clearInterval(M),M=null),N&&(a=N,N=null, +a()))}function b(b){a(b.instance)}function d(a){return xa().then(function(a){return WebAssembly.instantiate(a,e)}).then(a,function(a){y("failed to asynchronously prepare wasm: "+a);D(a)})}var e={env:Ga,wasi_snapshot_preview1:Ga};L++;c.monitorRunDependencies&&c.monitorRunDependencies(L);if(c.instantiateWasm)try{return c.instantiateWasm(e,a)}catch(g){return y("Module.instantiateWasm callback failed with error: "+g),!1}(function(){if(A||"function"!==typeof WebAssembly.instantiateStreaming||ta()||"function"!== +typeof fetch)return d(b);fetch(O,{credentials:"same-origin"}).then(function(a){return WebAssembly.instantiateStreaming(a,e).then(b,function(a){y("wasm streaming compile failed: "+a);y("falling back to ArrayBuffer instantiation");d(b)})})})();return{}}();c.asm=Ha;var ya=c.___wasm_call_ctors=function(){return(ya=c.___wasm_call_ctors=c.asm.p).apply(null,arguments)};c._convert_glsl_to_spirv=function(){return(c._convert_glsl_to_spirv=c.asm.q).apply(null,arguments)}; +c._destroy_output_buffer=function(){return(c._destroy_output_buffer=c.asm.r).apply(null,arguments)};c._malloc=function(){return(c._malloc=c.asm.s).apply(null,arguments)};var Fa=c._free=function(){return(Fa=c._free=c.asm.t).apply(null,arguments)},ja=c.stackSave=function(){return(ja=c.stackSave=c.asm.u).apply(null,arguments)},G=c.stackAlloc=function(){return(G=c.stackAlloc=c.asm.v).apply(null,arguments)},ka=c.stackRestore=function(){return(ka=c.stackRestore=c.asm.w).apply(null,arguments)}; +c.dynCall_vi=function(){return(c.dynCall_vi=c.asm.x).apply(null,arguments)};c.dynCall_v=function(){return(c.dynCall_v=c.asm.y).apply(null,arguments)};c.asm=Ha;var Y;c.then=function(a){if(Y)a(c);else{var b=c.onRuntimeInitialized;c.onRuntimeInitialized=function(){b&&b();a(c)}}return c};N=function Ia(){Y||Z();Y||(N=Ia)}; +function Z(){function a(){if(!Y&&(Y=!0,!fa)){K(pa);K(qa);if(c.onRuntimeInitialized)c.onRuntimeInitialized();if(c.postRun)for("function"==typeof c.postRun&&(c.postRun=[c.postRun]);c.postRun.length;){var a=c.postRun.shift();ra.unshift(a)}K(ra)}}if(!(0 { + const initialize = () => { + return new Promise(resolve => { + Module({ + locateFile() { + const i = import.meta.url.lastIndexOf('/') + return import.meta.url.substring(0, i) + '/glslang.wasm'; + }, + onRuntimeInitialized() { + resolve({ + compileGLSLZeroCopy: this.compileGLSLZeroCopy, + compileGLSL: this.compileGLSL, + }); + }, + }); + }); + }; + + let instance; + return () => { + if (!instance) { + instance = initialize(); + } + return instance; + }; +})(); diff --git a/tests/wpt/webgpu/tests/webgpu/third_party/glslang_js/lib/glslang.wasm b/tests/wpt/webgpu/tests/webgpu/third_party/glslang_js/lib/glslang.wasm new file mode 100644 index 0000000000000000000000000000000000000000..d951d65e063a930ad0d841848367f7b8cc6b2703 GIT binary patch literal 943680 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/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

    =&wvbKZ;3D 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

    to)Lm0fSo_Y1 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%0D>8!{WOv?OooUH+xW)|kf5$VN{jAX)7q6< zS0chH-R0;&^)@3ln}6qRMm|}rKmeoU(HMPomX2XtvlOpQqT+RN5+|pL%$6^Aja!J% z$Nl~!UxjG?)T=rb18s%aRYhm_3}{P;Ue?eQCcUc28chB65Jjoh)uIAjE?FuGVVz8u z6rr3I!th~C5>>RuTP`VTq?Z(>?fgkE#8p~upwDRPZGGNV0F}Juew(L-S(S`6k^2@T+_`j@3C)5fng|2)sJrKj>o#2O_Z zNlw+e6P(o65j!X{&tt9mToiRk?04}cZ7uBbKhj_wYAUj0Sp?Yy1e2SSkh_K2Ut_Ms zv+J`%E7=PU7HgBwDqFONh1?!y8mSmj3CS7f!39+GHIseMxP$$zcOwg)Y0;tcjbESGT9lt`mDUKJfKuR?d@4CtLaP zxcG9h9b-g;mM0=zcBR1}RmP~zgvcnI#wbOWUv_m2z8K!Z&2GLY7qFG~jXcs^^&SSG|k$l+4FdI?4hY`Q^sFxUKe4tS}Y2PA%h8j2|@6BEE1af_boXMV%#GB|X?kb9& zTM`LPqES{e!EBUKA7hAVBx)9j#G)!tvmgRjsjV8>hLl+^6YNG=LoqA)cAhnQt~QD_1fRcHnPACq_IAiBD7-ZZc0}# zG+aH8HElSHO*W?)kVL^`CwaGHhvq=dha^+I)C96*BAOgWr}281nMp03GN~1jl=Q!3 zLcGbzlQa^6se73S5j+ZYzgnioToHqAwuMKwOtdg^C_r+h>Nvv0QA|F6)CBR7SpUvU zCx=?OL;x<0@}sC^GoGz9=7#!@DZD~(-IiCmMs#%tDNn0>hF2L?)Rbh4wPMd1=85Ap z0(ZsPLb`pYyIY94$;!zx^`!z$G{lu$GuiCA

    Q-3CNk9$;pDn)F4QvnVbI(8uEns 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 M*Q~~_+N;z510LomssI20 literal 0 HcmV?d00001 From fa4d3cb3d250d35b6fef782b7b3a5a7f6b233254 Mon Sep 17 00:00:00 2001 From: Kunal Mohan Date: Sat, 25 Jul 2020 17:56:48 +0530 Subject: [PATCH 3/6] update expectations --- tests/wpt/webgpu/meta/webgpu/cts.html.ini | 15795 ++++++++++++++++ .../reftests/canvas_clear.html.ini | 2 + .../canvas_complex_bgra8unorm.html.ini | 2 + 3 files changed, 15799 insertions(+) create mode 100644 tests/wpt/webgpu/meta/webgpu/cts.html.ini create mode 100644 tests/wpt/webgpu/meta/webgpu/webgpu/web-platform/reftests/canvas_clear.html.ini create mode 100644 tests/wpt/webgpu/meta/webgpu/webgpu/web-platform/reftests/canvas_complex_bgra8unorm.html.ini diff --git a/tests/wpt/webgpu/meta/webgpu/cts.html.ini b/tests/wpt/webgpu/meta/webgpu/cts.html.ini new file mode 100644 index 00000000000..0c194e42090 --- /dev/null +++ b/tests/wpt/webgpu/meta/webgpu/cts.html.ini @@ -0,0 +1,15795 @@ +[cts.html?q=webgpu:idl,constants,flags:*] + [webgpu:idl,constants,flags:BufferUsage:] + expected: FAIL + + +[cts.html?q=webgpu:api,validation,createRenderPipeline:*] + [webgpu:api,validation,createRenderPipeline:sample_count_must_be_valid:sampleCount=2] + expected: FAIL + + [webgpu:api,validation,createRenderPipeline:color_formats_must_be_renderable:format="depth24plus-stencil8"] + expected: FAIL + + [webgpu:api,validation,createRenderPipeline:at_least_one_color_state_is_required:] + expected: FAIL + + [webgpu:api,validation,createRenderPipeline:sample_count_must_be_valid:sampleCount=8] + expected: FAIL + + [webgpu:api,validation,createRenderPipeline:color_formats_must_be_renderable:format="depth32float"] + expected: FAIL + + [webgpu:api,validation,createRenderPipeline:color_formats_must_be_renderable:format="rg8snorm"] + expected: FAIL + + [webgpu:api,validation,createRenderPipeline:color_formats_must_be_renderable:format="rg11b10float"] + expected: FAIL + + [webgpu:api,validation,createRenderPipeline:color_formats_must_be_renderable:format="depth24plus"] + expected: FAIL + + [webgpu:api,validation,createRenderPipeline:color_formats_must_be_renderable:format="rgba8snorm"] + expected: FAIL + + [webgpu:api,validation,createRenderPipeline:sample_count_must_be_equal_to_the_one_of_every_attachment_in_the_render_pass:attachmentSamples=4;pipelineSamples=1] + expected: FAIL + + [webgpu:api,validation,createRenderPipeline:sample_count_must_be_equal_to_the_one_of_every_attachment_in_the_render_pass:attachmentSamples=1;pipelineSamples=4] + expected: FAIL + + [webgpu:api,validation,createRenderPipeline:sample_count_must_be_valid:sampleCount=16] + expected: FAIL + + [webgpu:api,validation,createRenderPipeline:color_formats_must_be_renderable:format="r8snorm"] + expected: FAIL + + +[cts.html?q=webgpu:shader,execution,robust_access:*] + [webgpu:shader,execution,robust_access:bufferMemory:type="uint_vector4";memory="storage";access="write"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="uint_vector2";memory="storage";access="write"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="bool_vector4";memory="storage";access="write"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="uint_vector4";memory="uniform";access="read"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="uint_vector4";memory="storage";access="read"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="mat4x3";memory="storage";access="write"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="transposed_mat3x4";memory="uniform";access="read"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="uint_sizedArray";memory="storage";access="read"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="int_vector3";memory="storage";access="read"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="transposed_mat4x2";memory="uniform";access="read"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="float_vector2";memory="uniform";access="read"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="transposed_mat2x3";memory="uniform";access="read"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="transposed_mat3x4";memory="storage";access="read"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="mat4";memory="storage";access="read"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="transposed_mat4x3";memory="storage";access="write"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="mat4x3";memory="uniform";access="read"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="transposed_mat4x2";memory="storage";access="read"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="float_vector3";memory="uniform";access="read"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="uint_vector2";memory="uniform";access="read"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="transposed_mat4x3";memory="uniform";access="read"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="uint_vector2";memory="storage";access="read"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="transposed_mat3";memory="storage";access="write"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="mat2x3";memory="storage";access="read"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="mat4";memory="uniform";access="read"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="mat4x3";memory="storage";access="read"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="float_sizedArray";memory="storage";access="write"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="mat4x2";memory="storage";access="write"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="transposed_mat3";memory="storage";access="read"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="mat3x4";memory="uniform";access="read"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="float_vector2";memory="storage";access="write"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="transposed_mat3x2";memory="uniform";access="read"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="transposed_mat2";memory="storage";access="write"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="bool_sizedArray";memory="storage";access="read"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="mat4x2";memory="storage";access="read"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="float_vector3";memory="storage";access="write"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="uint_sizedArray";memory="uniform";access="read"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="transposed_mat3x2";memory="storage";access="read"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="mat2x4";memory="storage";access="read"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="transposed_mat4";memory="uniform";access="read"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="transposed_mat3";memory="uniform";access="read"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="transposed_mat3x4";memory="storage";access="write"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="int_vector4";memory="storage";access="read"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="uint_unsizedArray";memory="storage";access="write"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="bool_vector3";memory="storage";access="write"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="int_vector2";memory="uniform";access="read"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="bool_vector3";memory="storage";access="read"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="int_vector4";memory="storage";access="write"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="int_sizedArray";memory="storage";access="read"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="float_vector4";memory="storage";access="read"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="mat3x2";memory="storage";access="write"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="transposed_mat4x2";memory="storage";access="write"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="float_sizedArray";memory="storage";access="read"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="uint_sizedArray";memory="storage";access="write"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="int_vector4";memory="uniform";access="read"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="bool_vector4";memory="uniform";access="read"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="transposed_mat2";memory="uniform";access="read"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="mat2x4";memory="storage";access="write"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="mat3x2";memory="uniform";access="read"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="transposed_mat2x4";memory="storage";access="write"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="mat4";memory="storage";access="write"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="uint_unsizedArray";memory="storage";access="read"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="float_vector4";memory="uniform";access="read"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="int_sizedArray";memory="uniform";access="read"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="transposed_mat2x4";memory="storage";access="read"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="float_vector2";memory="storage";access="read"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="mat2";memory="storage";access="read"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="bool_unsizedArray";memory="storage";access="write"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="mat2x4";memory="uniform";access="read"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="float_unsizedArray";memory="storage";access="write"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="mat3";memory="storage";access="read"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="transposed_mat2x3";memory="storage";access="read"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="mat2";memory="storage";access="write"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="float_sizedArray";memory="uniform";access="read"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="mat3";memory="uniform";access="read"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="transposed_mat4x3";memory="storage";access="read"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="bool_vector2";memory="storage";access="write"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="mat3x2";memory="storage";access="read"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="transposed_mat2";memory="storage";access="read"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="int_vector2";memory="storage";access="write"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="int_unsizedArray";memory="storage";access="write"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="mat2";memory="uniform";access="read"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="mat3x4";memory="storage";access="write"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="uint_vector3";memory="storage";access="write"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="transposed_mat2x3";memory="storage";access="write"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="bool_sizedArray";memory="uniform";access="read"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="transposed_mat4";memory="storage";access="write"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="mat2x3";memory="storage";access="write"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="bool_sizedArray";memory="storage";access="write"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="mat3";memory="storage";access="write"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="uint_vector3";memory="storage";access="read"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="mat2x3";memory="uniform";access="read"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="int_vector2";memory="storage";access="read"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="mat3x4";memory="storage";access="read"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="bool_vector2";memory="uniform";access="read"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="float_unsizedArray";memory="storage";access="read"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="int_vector3";memory="storage";access="write"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="float_vector3";memory="storage";access="read"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="int_vector3";memory="uniform";access="read"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="bool_vector3";memory="uniform";access="read"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="bool_vector2";memory="storage";access="read"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="int_sizedArray";memory="storage";access="write"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="bool_vector4";memory="storage";access="read"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="uint_vector3";memory="uniform";access="read"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="int_unsizedArray";memory="storage";access="read"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="float_vector4";memory="storage";access="write"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="transposed_mat2x4";memory="uniform";access="read"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="bool_unsizedArray";memory="storage";access="read"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="transposed_mat4";memory="storage";access="read"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="mat4x2";memory="uniform";access="read"] + expected: FAIL + + [webgpu:shader,execution,robust_access:bufferMemory:type="transposed_mat3x2";memory="storage";access="write"] + expected: FAIL + + +[cts.html?q=webgpu:api,validation,render_pass:*] + [webgpu:api,validation,render_pass:it_is_invalid_to_draw_in_a_render_pass_with_missing_bind_groups:setBindGroup1=true;setBindGroup2=false] + expected: FAIL + + [webgpu:api,validation,render_pass:it_is_invalid_to_draw_in_a_render_pass_with_missing_bind_groups:setBindGroup1=false;setBindGroup2=true] + expected: FAIL + + [webgpu:api,validation,render_pass:it_is_invalid_to_draw_in_a_render_pass_with_missing_bind_groups:setBindGroup1=false;setBindGroup2=false] + expected: FAIL + + +[cts.html?q=webgpu:api,validation,createTexture:*] + expected: CRASH + [webgpu:api,validation,createTexture:validation_of_mipLevelCount:width=32;height=31;mipLevelCount=7] + expected: FAIL + + [webgpu:api,validation,createTexture:it_is_invalid_to_have_an_output_attachment_texture_with_non_renderable_format:format="r8snorm"] + expected: FAIL + + [webgpu:api,validation,createTexture:it_is_invalid_to_submit_a_destroyed_texture_before_and_after_encode:destroyBeforeEncode=false;destroyAfterEncode=true] + expected: FAIL + + [webgpu:api,validation,createTexture:it_is_invalid_to_have_an_output_attachment_texture_with_non_renderable_format:format="rg11b10float"] + expected: FAIL + + [webgpu:api,validation,createTexture:it_is_invalid_to_submit_a_destroyed_texture_before_and_after_encode:destroyBeforeEncode=true;destroyAfterEncode=false] + expected: FAIL + + [webgpu:api,validation,createTexture:validation_of_sampleCount:sampleCount=0] + expected: FAIL + + [webgpu:api,validation,createTexture:validation_of_sampleCount:sampleCount=2] + expected: FAIL + + [webgpu:api,validation,createTexture:validation_of_sampleCount:sampleCount=3] + expected: FAIL + + [webgpu:api,validation,createTexture:validation_of_sampleCount:sampleCount=8] + expected: FAIL + + [webgpu:api,validation,createTexture:validation_of_sampleCount:sampleCount=16] + expected: FAIL + + [webgpu:api,validation,createTexture:validation_of_sampleCount:sampleCount=4;arrayLayerCount=2] + expected: FAIL + + [webgpu:api,validation,createTexture:validation_of_mipLevelCount:width=32;height=32;mipLevelCount=0] + expected: FAIL + + [webgpu:api,validation,createTexture:validation_of_mipLevelCount:width=32;height=32;mipLevelCount=100] + expected: FAIL + + [webgpu:api,validation,createTexture:validation_of_sampleCount:sampleCount=4;mipLevelCount=2] + expected: FAIL + + [webgpu:api,validation,createTexture:it_is_invalid_to_have_an_output_attachment_texture_with_non_renderable_format:format="rg8snorm"] + expected: FAIL + + [webgpu:api,validation,createTexture:it_is_invalid_to_have_an_output_attachment_texture_with_non_renderable_format:format="rgba8snorm"] + expected: FAIL + + [webgpu:api,validation,createTexture:validation_of_mipLevelCount:width=31;height=32;mipLevelCount=7] + expected: FAIL + + +[cts.html?q=webgpu:api,operation,buffers,map:*] + [webgpu:api,operation,buffers,map:createBufferMapped:size=12;mappable=false] + expected: FAIL + + [webgpu:api,operation,buffers,map:createBufferMapped:size=12;mappable=true] + expected: FAIL + + [webgpu:api,operation,buffers,map:createBufferMapped:size=524288;mappable=false] + expected: FAIL + + [webgpu:api,operation,buffers,map:mapReadAsync:size=12] + expected: FAIL + + [webgpu:api,operation,buffers,map:createBufferMapped:size=524288;mappable=true] + expected: FAIL + + [webgpu:api,operation,buffers,map:mapReadAsync:size=524288] + expected: FAIL + + [webgpu:api,operation,buffers,map:mapWriteAsync:size=12] + expected: FAIL + + [webgpu:api,operation,buffers,map:mapWriteAsync:size=524288] + expected: FAIL + + +[cts.html?q=webgpu:api,operation,command_buffer,compute,basic:*] + [webgpu:api,operation,command_buffer,compute,basic:memcpy:] + expected: FAIL + + +[cts.html?q=webgpu:api,operation,command_buffer,render,storeop:*] + [webgpu:api,operation,command_buffer,render,storeop:storeOp_controls_whether_1x1_drawn_quad_is_stored:storeOp="store"] + expected: FAIL + + [webgpu:api,operation,command_buffer,render,storeop:storeOp_controls_whether_1x1_drawn_quad_is_stored:storeOp="clear"] + expected: FAIL + + +[cts.html?q=webgpu:api,operation,resource_init,copied_texture_clear:*] + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r16uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r16sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="depth32float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r32float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba16sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg16float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r16float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgb10a2unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg32sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r32sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba32sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8snorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm-srgb";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="depth32float";aspect="depth-only";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg16sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg16float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba32uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="depth32float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg16sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg32uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm-srgb";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba32uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="depth32float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm-srgb";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg16uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgb10a2unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r32uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg16sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg32float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r32sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg16float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8snorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg16sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgb10a2unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8snorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba16uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg16uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm-srgb";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba16uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="depth32float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r16float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba16float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg16sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba16float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r16sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg32uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba16float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba32uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="depth32float";aspect="depth-only";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg32uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgb10a2unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm-srgb";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8snorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg32float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba32float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg16float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba16float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm-srgb";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba16uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba16float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r16float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="depth32float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba16float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm-srgb";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8snorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba32sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba16sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r16sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba32float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba32float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba32sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg32float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba16float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm-srgb";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba16float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg16uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="depth32float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r32sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgb10a2unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r16float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg32uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r32float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgb10a2unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg32float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r16float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="depth32float";aspect="depth-only";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba16uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg32uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r32float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r16sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="depth32float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg32uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r32sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba32float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r16float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg32sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r16float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg32uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8snorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba16uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgb10a2unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba32sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r16uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm-srgb";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba16float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r32uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm-srgb";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg16sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba32float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="depth32float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba32float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg32uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgb10a2unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r32float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r32uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba16uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg16uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba32sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm-srgb";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r16uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba16sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba32float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="depth32float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba32uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgb10a2unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r32uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="depth32float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg16sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="depth32float";aspect="depth-only";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg32float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg32float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r16float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg16sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r16uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8snorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba32sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba16float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm-srgb";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r32sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8snorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r32float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm-srgb";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg32sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="depth32float";aspect="depth-only";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r16float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg32sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg16float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba16sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg32sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg32sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba32uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg16uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba32uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r32sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm-srgb";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba16float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8snorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba16uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba32float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="depth32float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg11b10float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba32sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8snorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8snorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm-srgb";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r32sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba16uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="depth32float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r32sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg32float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba16sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg32uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r16float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8snorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba32sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r32sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba32uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r16sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r16float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba32sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg32uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg32uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba16sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r32uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg16float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r16sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg32sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="depth32float";aspect="depth-only";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r16uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r16sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm-srgb";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba16sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="depth32float";aspect="depth-only";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r16float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba16uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r16uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg16uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r32float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba32float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgb10a2unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba32uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg32sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r16float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba32uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r16sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba32uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8snorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm-srgb";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba16sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm-srgb";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="depth32float";aspect="depth-only";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg16uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg32uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg16sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba32uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r16sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba16uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba16sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="depth32float";aspect="depth-only";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg32uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg16float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba32float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg16float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r16float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg32uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8snorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba32uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r32uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg32float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r32uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8snorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg16float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba32sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg11b10float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="depth32float";aspect="depth-only";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba32float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r16uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba32sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r32sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg32sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba16uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r16uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="depth32float";aspect="depth-only";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r32sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba16float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r32float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba32uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg16sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg16float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm-srgb";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm-srgb";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba32uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba32sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm-srgb";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r16sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm-srgb";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r32float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba16float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r16float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba32uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r16uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r32uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r32uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba32uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg16uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="depth32float";aspect="depth-only";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba16uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm-srgb";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg32sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg32float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg16float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8snorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r32uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm-srgb";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg16uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba16float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba32uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba32uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r16sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="depth32float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba32float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg11b10float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba32sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8snorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba16sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgb10a2unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg32sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r16sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r32uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8snorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba16float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r32float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm-srgb";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r16float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg16sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r32uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="depth32float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r32uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba16uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba16sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba32float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm-srgb";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r32float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r16sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgb10a2unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="depth32float";aspect="depth-only";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg16sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8snorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r16float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba32uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba16float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm-srgb";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r16sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba32float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r32uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r16uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg32uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg16sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba32float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="depth32float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg16uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8snorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r16sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="depth32float";aspect="depth-only";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r32uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r32float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg16uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba32float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg32float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r32uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba16uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba16sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r16float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba16uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r16sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm-srgb";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba32sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba16float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r32sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg32float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba32float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r16float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg32sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg32sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r16uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm-srgb";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg16float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8snorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r16sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r32float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg16sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r16float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg16uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r32uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg16sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg32uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="depth32float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgb10a2unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm-srgb";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg32uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg32sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r16uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba32float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm-srgb";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba16float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="depth32float";aspect="depth-only";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg16sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm-srgb";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r32uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg32sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r16sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm-srgb";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r32sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba16float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg16float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg32float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba16uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg16float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg32float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg32float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r32uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba16uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba16uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="depth32float";aspect="depth-only";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8snorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba16float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm-srgb";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba16uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r32sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg11b10float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg16uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r32sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg32float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r32float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba16float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba32uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgb10a2unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg32float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba32float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba16uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba32float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8snorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba16uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg32uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm-srgb";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r16uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm-srgb";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm-srgb";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgb10a2unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r16float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm-srgb";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba16uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba16uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg32sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r32float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg11b10float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgb10a2unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg16float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r16uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg32uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r16uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r32sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r32uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="depth32float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg16uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8snorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgb10a2unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba32sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r16sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba32sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg16uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r32float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba32float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r32float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r32sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba16uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba16float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r32float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8snorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba16sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg32uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg16sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg16float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg16sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r16float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8snorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg16sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r32float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg32uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg32uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="depth32float";aspect="depth-only";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba32float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba16sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba32float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg32uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8snorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r16uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg16float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba16sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg16sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg16float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r32uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r16sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba16sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgb10a2unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r16uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg32sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r32float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg16float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg32uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="depth32float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba16float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba16float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba16uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r16sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r32uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="depth32float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg16sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg16sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm-srgb";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r32sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg32sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba32sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="depth32float";aspect="depth-only";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba32sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg32float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba16sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r16uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r16float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="depth32float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg32sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="depth32float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm-srgb";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg16sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r16float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba32float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg16float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r16sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r16float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8snorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba16sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r32float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg11b10float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg32sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="depth32float";aspect="depth-only";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg32float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg16sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm-srgb";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r16uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgb10a2unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8snorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r16float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg16uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r32float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r16uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg32float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg16uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba16sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba32sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba16sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg16uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r32float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r32uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8snorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r32sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg16float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg16float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba16float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg16uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg16uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba32uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba32float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r16sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba32sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r32uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba16sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgb10a2unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm-srgb";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba32sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r16uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm-srgb";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r32float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg16uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgb10a2unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba32uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg11b10float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba16sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r16sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba32uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg16float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r32uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r32float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r16sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba16uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg32sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r16sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba32float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg11b10float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8snorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="depth32float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba32sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg16uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg32float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg16float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r16sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg16float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg32sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba32float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba32float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm-srgb";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="depth32float";aspect="depth-only";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r32float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r16uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r16sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm-srgb";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgb10a2unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg16float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba16uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg16sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg32float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgb10a2unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg11b10float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm-srgb";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8snorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg32uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg32uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg32uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="depth32float";aspect="depth-only";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r16uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg32uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg32float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r32sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba16uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba32float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r32float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg32uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="depth32float";aspect="depth-only";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba32sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm-srgb";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgb10a2unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8snorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgb10a2unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg32float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba32uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgb10a2unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r32sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="depth32float";aspect="depth-only";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r16float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg16sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg32float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r32sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm-srgb";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r32uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm-srgb";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="depth32float";aspect="depth-only";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8snorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="depth32float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r16uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r32uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8snorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r16uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8snorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r16uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm-srgb";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg16sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="depth32float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg16uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg32float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg16uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r32sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8snorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba16sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba16sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg16float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="depth32float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg11b10float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba32uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg16sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg32sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba32sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8snorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg16uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm-srgb";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r16float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba32sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba32uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg11b10float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba32uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgb10a2unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba16uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgb10a2unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba16float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba16sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r16sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="depth32float";aspect="depth-only";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r32float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba32sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r16uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8snorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba16float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg16uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg32float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg16uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r32sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba32uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba32sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="depth32float";aspect="depth-only";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm-srgb";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r32float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="depth32float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba32uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm-srgb";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm-srgb";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba16float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg32sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg32sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg32sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba16sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r16uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm-srgb";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r32sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm-srgb";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg16uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8snorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba32sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8snorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba32float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg16float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm-srgb";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgb10a2unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8snorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="depth32float";aspect="depth-only";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba16uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg16float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg11b10float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="depth32float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="depth32float";aspect="depth-only";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg16uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm-srgb";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg32uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="depth32float";aspect="depth-only";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r16uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8snorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba32float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r16float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg16uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg32sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgb10a2unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r16float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="depth32float";aspect="depth-only";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgb10a2unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg11b10float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg32sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="depth32float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba32sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="depth32float";aspect="depth-only";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r32uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba16uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba32uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg11b10float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="depth32float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r16uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba16float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg16float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg32float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg16float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg32sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm-srgb";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r16uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg32float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg16sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg11b10float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba16sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r32sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8snorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm-srgb";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg32uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="depth32float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r16float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba32uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg16sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8snorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba16uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba16sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r32sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm-srgb";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba32float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg32float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r16sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="depth32float";aspect="depth-only";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba16float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba16float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg32sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba16sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r32float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r32uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg32float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8snorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba16sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r16sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r32float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="depth32float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba32sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg32uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg32float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm-srgb";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r32sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba32sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba32uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba32sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg32float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg16sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="depth32float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r32float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8snorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r32sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r32float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r16sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r32uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba16sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg16sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg32sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r16float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r8unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r32sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8snorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg16uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r32sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg16uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba16sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r32sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba16float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg16float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg11b10float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r32uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r16uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgb10a2unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg8unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="r32uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm-srgb";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm-srgb";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToBuffer";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,copied_texture_clear:uninitialized_texture_is_zero:format="rg32sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="CopyToTexture";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + +[cts.html?q=webgpu:api,validation,setViewport:*] + [webgpu:api,validation,setViewport:use_of_setViewport:x=0;y=0;width=1;height=-1;minDepth=0;maxDepth=1] + expected: FAIL + + [webgpu:api,validation,setViewport:use_of_setViewport:x=0;y=0;width=1;height=1;minDepth=10;maxDepth=1] + expected: FAIL + + [webgpu:api,validation,setViewport:use_of_setViewport:x=0;y=0;width=1;height=0;minDepth=0;maxDepth=1] + expected: FAIL + + [webgpu:api,validation,setViewport:use_of_setViewport:x=0;y=0;width=1;height=1;minDepth=-1;maxDepth=1] + expected: FAIL + + [webgpu:api,validation,setViewport:use_of_setViewport:x=0;y=0;width=0;height=1;minDepth=0;maxDepth=1] + expected: FAIL + + [webgpu:api,validation,setViewport:use_of_setViewport:x=0;y=0;width=1;height=1;minDepth=0;maxDepth=-1] + expected: FAIL + + [webgpu:api,validation,setViewport:use_of_setViewport:x=0;y=0;width=0;height=0;minDepth=0;maxDepth=1] + expected: FAIL + + [webgpu:api,validation,setViewport:use_of_setViewport:x=0;y=0;width=-1;height=1;minDepth=0;maxDepth=1] + expected: FAIL + + [webgpu:api,validation,setViewport:use_of_setViewport:x=0;y=0;width=1;height=1;minDepth=0;maxDepth=10] + expected: FAIL + + +[cts.html?q=webgpu:web-platform,copyImageBitmapToTexture:*] + expected: TIMEOUT + +[cts.html?q=webgpu:api,operation,buffers,map_oom:*] + [webgpu:api,operation,buffers,map_oom:mapWriteAsync:] + expected: FAIL + + [webgpu:api,operation,buffers,map_oom:mapReadAsync:] + expected: FAIL + + [webgpu:api,operation,buffers,map_oom:createBufferMapped:] + expected: FAIL + + +[cts.html?q=webgpu:api,validation,error_scope:*] + [webgpu:api,validation,error_scope:if_no_error_scope_handles_an_error_it_fires_an_uncapturederror_event:] + expected: FAIL + + [webgpu:api,validation,error_scope:if_an_error_scope_matches_an_error_it_does_not_bubble_to_the_parent_scope:] + expected: FAIL + + [webgpu:api,validation,error_scope:errors_bubble_to_the_parent_scope_if_not_handled_by_the_current_scope:] + expected: FAIL + + [webgpu:api,validation,error_scope:simple_case_where_the_error_scope_catches_an_error:] + expected: FAIL + + +[cts.html?q=webgpu:api,validation,createBindGroupLayout:*] + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_bind_group_layout:maxedType="sampled-texture";maxedVisibility=2;extraType="sampled-texture";extraVisibility=4] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_bind_group_layout:maxedType="sampled-texture";maxedVisibility=2;extraType="sampled-texture";extraVisibility=1] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:texture_component_type:type="readonly-storage-buffer";textureComponentType="float"] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:min_buffer_binding_size:type="comparison-sampler";minBufferBindingSize=4] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_pipeline_layout:maxedType="comparison-sampler";maxedVisibility=1;extraType="comparison-sampler";extraVisibility=1] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:visibility_and_dynamic_offsets:type="writeonly-storage-texture";hasDynamicOffset=false;visibility=7] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:visibility_and_dynamic_offsets:type="writeonly-storage-texture";hasDynamicOffset=false;visibility=5] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:visibility_and_dynamic_offsets:type="writeonly-storage-texture";hasDynamicOffset=false;visibility=3] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:visibility_and_dynamic_offsets:type="writeonly-storage-texture";hasDynamicOffset=false;visibility=1] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_bind_group_layout:maxedType="comparison-sampler";maxedVisibility=2;extraType="sampled-texture";extraVisibility=1] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_bind_group_layout:maxedType="comparison-sampler";maxedVisibility=2;extraType="sampled-texture";extraVisibility=4] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:view_dimension:type="comparison-sampler";viewDimension="2d"] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_pipeline_layout:maxedType="uniform-buffer";maxedVisibility=1;extraType="uniform-buffer";extraVisibility=1] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_pipeline_layout:maxedType="sampled-texture";maxedVisibility=2;extraType="sampled-texture";extraVisibility=2] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_bind_group_layout:maxedType="sampler";maxedVisibility=4;extraType="sampled-texture";extraVisibility=2] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_bind_group_layout:maxedType="sampler";maxedVisibility=4;extraType="sampled-texture";extraVisibility=1] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_bind_group_layout:maxedType="sampler";maxedVisibility=4;extraType="sampled-texture";extraVisibility=4] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_pipeline_layout:maxedType="sampler";maxedVisibility=2;extraType="comparison-sampler";extraVisibility=2] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:texture_component_type:type="storage-buffer";textureComponentType="uint"] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:multisampled:type="writeonly-storage-texture";multisampled=true] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:multisampled:type="sampler";multisampled=undefined] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:visibility_and_dynamic_offsets:type="sampler";hasDynamicOffset=true;visibility=3] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:visibility_and_dynamic_offsets:type="sampler";hasDynamicOffset=true;visibility=2] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:visibility_and_dynamic_offsets:type="sampler";hasDynamicOffset=true;visibility=1] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:visibility_and_dynamic_offsets:type="sampler";hasDynamicOffset=true;visibility=0] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:visibility_and_dynamic_offsets:type="sampler";hasDynamicOffset=true;visibility=7] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:view_dimension:type="comparison-sampler";viewDimension="cube-array"] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:visibility_and_dynamic_offsets:type="sampler";hasDynamicOffset=true;visibility=5] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:visibility_and_dynamic_offsets:type="sampler";hasDynamicOffset=true;visibility=4] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_bind_group_layout:maxedType="sampled-texture";maxedVisibility=4;extraType="sampled-texture";extraVisibility=2] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_bind_group_layout:maxedType="sampled-texture";maxedVisibility=4;extraType="sampled-texture";extraVisibility=1] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:view_dimension:type="storage-buffer";viewDimension="3d"] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_bind_group_layout:maxedType="writeonly-storage-texture";maxedVisibility=4;extraType="writeonly-storage-texture";extraVisibility=4] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_bind_group_layout:maxedType="storage-buffer";maxedVisibility=4;extraType="storage-buffer";extraVisibility=4] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:view_dimension:type="uniform-buffer";viewDimension="2d"] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:view_dimension:type="readonly-storage-buffer";viewDimension="cube-array"] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:multisampled:type="readonly-storage-buffer";multisampled=true] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:view_dimension:type="comparison-sampler";viewDimension="cube"] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:min_buffer_binding_size:type="sampler";minBufferBindingSize=4] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:storage_texture_format:type="storage-buffer";storageTextureFormat="rgba8unorm"] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:view_dimension:type="sampler";viewDimension="1d"] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_bind_group_layout:maxedType="sampler";maxedVisibility=1;extraType="sampler";extraVisibility=4] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_bind_group_layout:maxedType="sampler";maxedVisibility=1;extraType="sampler";extraVisibility=2] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_bind_group_layout:maxedType="readonly-storage-buffer";maxedVisibility=2;extraType="storage-buffer";extraVisibility=2] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_bind_group_layout:maxedType="comparison-sampler";maxedVisibility=2;extraType="comparison-sampler";extraVisibility=1] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:multisampled:type="readonly-storage-buffer";multisampled=undefined] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_bind_group_layout:maxedType="sampler";maxedVisibility=4;extraType="comparison-sampler";extraVisibility=2] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_bind_group_layout:maxedType="sampler";maxedVisibility=4;extraType="comparison-sampler";extraVisibility=1] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_pipeline_layout:maxedType="comparison-sampler";maxedVisibility=2;extraType="sampler";extraVisibility=2] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_bind_group_layout:maxedType="readonly-storage-texture";maxedVisibility=1;extraType="readonly-storage-texture";extraVisibility=1] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_pipeline_layout:maxedType="readonly-storage-buffer";maxedVisibility=1;extraType="readonly-storage-buffer";extraVisibility=1] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:multisampled:type="uniform-buffer";multisampled=true] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_pipeline_layout:maxedType="readonly-storage-texture";maxedVisibility=4;extraType="readonly-storage-texture";extraVisibility=4] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:texture_component_type:type="readonly-storage-texture";textureComponentType="uint"] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_bind_group_layout:maxedType="sampler";maxedVisibility=2;extraType="sampled-texture";extraVisibility=1] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_bind_group_layout:maxedType="sampler";maxedVisibility=2;extraType="sampled-texture";extraVisibility=4] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:min_buffer_binding_size:type="writeonly-storage-texture";minBufferBindingSize=4] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_bind_group_layout:maxedType="comparison-sampler";maxedVisibility=2;extraType="comparison-sampler";extraVisibility=4] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:view_dimension:type="readonly-storage-buffer";viewDimension="cube"] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:multisampled:type="comparison-sampler";multisampled=undefined] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_pipeline_layout:maxedType="sampler";maxedVisibility=4;extraType="comparison-sampler";extraVisibility=4] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:view_dimension:type="sampler";viewDimension="2d-array"] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_pipeline_layout:maxedType="storage-buffer";maxedVisibility=4;extraType="readonly-storage-buffer";extraVisibility=4] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:multisampled:type="readonly-storage-texture";multisampled=true] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_bind_group_layout:maxedType="uniform-buffer";maxedVisibility=2;extraType="uniform-buffer";extraVisibility=2] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_bind_group_layout:maxedType="readonly-storage-buffer";maxedVisibility=1;extraType="readonly-storage-buffer";extraVisibility=1] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_bind_group_layout:maxedType="sampler";maxedVisibility=2;extraType="sampler";extraVisibility=1] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_bind_group_layout:maxedType="comparison-sampler";maxedVisibility=1;extraType="sampled-texture";extraVisibility=1] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_bind_group_layout:maxedType="comparison-sampler";maxedVisibility=1;extraType="sampled-texture";extraVisibility=2] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_bind_group_layout:maxedType="comparison-sampler";maxedVisibility=1;extraType="sampled-texture";extraVisibility=4] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_bind_group_layout:maxedType="sampler";maxedVisibility=2;extraType="sampler";extraVisibility=4] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:view_dimension:type="sampler";viewDimension="cube-array"] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_pipeline_layout:maxedType="sampled-texture";maxedVisibility=4;extraType="sampled-texture";extraVisibility=4] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:view_dimension:type="storage-buffer";viewDimension="2d"] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:texture_component_type:type="uniform-buffer";textureComponentType="uint"] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:texture_component_type:type="writeonly-storage-texture";textureComponentType="uint"] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:view_dimension:type="sampler";viewDimension="cube"] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_bind_group_layout:maxedType="comparison-sampler";maxedVisibility=4;extraType="comparison-sampler";extraVisibility=2] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_bind_group_layout:maxedType="comparison-sampler";maxedVisibility=4;extraType="comparison-sampler";extraVisibility=1] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:multisampled:type="uniform-buffer";multisampled=undefined] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:texture_component_type:type="readonly-storage-texture";textureComponentType="float"] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:texture_component_type:type="readonly-storage-buffer";textureComponentType="uint"] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_bind_group_layout:maxedType="readonly-storage-buffer";maxedVisibility=4;extraType="readonly-storage-buffer";extraVisibility=4] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:visibility_and_dynamic_offsets:type="comparison-sampler";hasDynamicOffset=true;visibility=6] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_pipeline_layout:maxedType="writeonly-storage-texture";maxedVisibility=2;extraType="readonly-storage-texture";extraVisibility=2] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:multisampled:type="readonly-storage-texture";multisampled=undefined] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_bind_group_layout:maxedType="sampled-texture";maxedVisibility=1;extraType="sampled-texture";extraVisibility=4] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_bind_group_layout:maxedType="sampled-texture";maxedVisibility=1;extraType="sampled-texture";extraVisibility=2] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:view_dimension:type="sampler";viewDimension="2d"] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_bind_group_layout:maxedType="storage-buffer";maxedVisibility=2;extraType="storage-buffer";extraVisibility=2] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:texture_component_type:type="writeonly-storage-texture";textureComponentType="sint"] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:storage_texture_format:type="uniform-buffer";storageTextureFormat="rgba8unorm"] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:texture_component_type:type="uniform-buffer";textureComponentType="sint"] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:view_dimension:type="uniform-buffer";viewDimension="2d-array"] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:min_buffer_binding_size:type="sampled-texture";minBufferBindingSize=4] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:storage_texture_format:type="sampled-texture";storageTextureFormat="rgba8unorm"] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_pipeline_layout:maxedType="readonly-storage-texture";maxedVisibility=4;extraType="writeonly-storage-texture";extraVisibility=4] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:texture_component_type:type="sampler";textureComponentType="uint"] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:view_dimension:type="uniform-buffer";viewDimension="cube-array"] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_pipeline_layout:maxedType="storage-buffer";maxedVisibility=2;extraType="readonly-storage-buffer";extraVisibility=2] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_bind_group_layout:maxedType="sampled-texture";maxedVisibility=2;extraType="sampler";extraVisibility=4] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_bind_group_layout:maxedType="sampled-texture";maxedVisibility=2;extraType="sampler";extraVisibility=1] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_bind_group_layout:maxedType="sampled-texture";maxedVisibility=2;extraType="sampler";extraVisibility=2] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_pipeline_layout:maxedType="readonly-storage-texture";maxedVisibility=2;extraType="writeonly-storage-texture";extraVisibility=2] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_bind_group_layout:maxedType="sampler";maxedVisibility=2;extraType="sampled-texture";extraVisibility=2] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:view_dimension:type="readonly-storage-buffer";viewDimension="1d"] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:number_of_dynamic_buffers_exceeds_the_maximum_value:type="storage-buffer";maxDynamicBufferCount=4] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_pipeline_layout:maxedType="readonly-storage-texture";maxedVisibility=1;extraType="readonly-storage-texture";extraVisibility=1] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:multisampled:type="storage-buffer";multisampled=undefined] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:multisampled:type="comparison-sampler";multisampled=true] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:texture_component_type:type="comparison-sampler";textureComponentType="float"] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:storage_texture_format:type="comparison-sampler";storageTextureFormat="rgba8unorm"] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:view_dimension:type="comparison-sampler";viewDimension="2d-array"] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:view_dimension:type="readonly-storage-buffer";viewDimension="2d-array"] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_pipeline_layout:maxedType="writeonly-storage-texture";maxedVisibility=4;extraType="readonly-storage-texture";extraVisibility=4] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_pipeline_layout:maxedType="comparison-sampler";maxedVisibility=1;extraType="sampler";extraVisibility=1] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_bind_group_layout:maxedType="sampler";maxedVisibility=1;extraType="comparison-sampler";extraVisibility=4] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:texture_component_type:type="storage-buffer";textureComponentType="float"] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_pipeline_layout:maxedType="comparison-sampler";maxedVisibility=4;extraType="sampler";extraVisibility=4] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_pipeline_layout:maxedType="sampler";maxedVisibility=1;extraType="sampler";extraVisibility=1] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:texture_component_type:type="readonly-storage-texture";textureComponentType="sint"] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:texture_component_type:type="readonly-storage-buffer";textureComponentType="sint"] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:texture_component_type:type="writeonly-storage-texture";textureComponentType="float"] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_bind_group_layout:maxedType="uniform-buffer";maxedVisibility=1;extraType="uniform-buffer";extraVisibility=1] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_pipeline_layout:maxedType="uniform-buffer";maxedVisibility=2;extraType="uniform-buffer";extraVisibility=2] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_bind_group_layout:maxedType="comparison-sampler";maxedVisibility=2;extraType="sampler";extraVisibility=1] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_bind_group_layout:maxedType="comparison-sampler";maxedVisibility=2;extraType="sampler";extraVisibility=4] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:storage_texture_format:type="sampler";storageTextureFormat="rgba8unorm"] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:view_dimension:type="storage-buffer";viewDimension="cube"] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_bind_group_layout:maxedType="sampler";maxedVisibility=4;extraType="sampler";extraVisibility=2] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_bind_group_layout:maxedType="sampler";maxedVisibility=4;extraType="sampler";extraVisibility=1] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:view_dimension:type="readonly-storage-buffer";viewDimension="2d"] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_pipeline_layout:maxedType="comparison-sampler";maxedVisibility=4;extraType="comparison-sampler";extraVisibility=4] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_bind_group_layout:maxedType="sampler";maxedVisibility=2;extraType="comparison-sampler";extraVisibility=1] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_bind_group_layout:maxedType="sampler";maxedVisibility=2;extraType="comparison-sampler";extraVisibility=4] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:texture_component_type:type="storage-buffer";textureComponentType="sint"] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_bind_group_layout:maxedType="comparison-sampler";maxedVisibility=4;extraType="sampler";extraVisibility=1] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_bind_group_layout:maxedType="comparison-sampler";maxedVisibility=4;extraType="sampler";extraVisibility=2] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:view_dimension:type="uniform-buffer";viewDimension="3d"] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_pipeline_layout:maxedType="sampler";maxedVisibility=1;extraType="comparison-sampler";extraVisibility=1] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:visibility_and_dynamic_offsets:type="writeonly-storage-texture";hasDynamicOffset=true;visibility=4] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:visibility_and_dynamic_offsets:type="writeonly-storage-texture";hasDynamicOffset=true;visibility=5] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:visibility_and_dynamic_offsets:type="writeonly-storage-texture";hasDynamicOffset=true;visibility=6] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:visibility_and_dynamic_offsets:type="writeonly-storage-texture";hasDynamicOffset=true;visibility=7] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:visibility_and_dynamic_offsets:type="writeonly-storage-texture";hasDynamicOffset=true;visibility=0] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:visibility_and_dynamic_offsets:type="writeonly-storage-texture";hasDynamicOffset=true;visibility=1] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:visibility_and_dynamic_offsets:type="writeonly-storage-texture";hasDynamicOffset=true;visibility=2] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:visibility_and_dynamic_offsets:type="writeonly-storage-texture";hasDynamicOffset=true;visibility=3] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:min_buffer_binding_size:type="readonly-storage-texture";minBufferBindingSize=4] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:texture_component_type:type="sampler";textureComponentType="float"] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:visibility_and_dynamic_offsets:type="sampler";hasDynamicOffset=true;visibility=6] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:view_dimension:type="uniform-buffer";viewDimension="cube"] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_bind_group_layout:maxedType="readonly-storage-buffer";maxedVisibility=4;extraType="storage-buffer";extraVisibility=4] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:texture_component_type:type="comparison-sampler";textureComponentType="sint"] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_pipeline_layout:maxedType="readonly-storage-texture";maxedVisibility=2;extraType="readonly-storage-texture";extraVisibility=2] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_pipeline_layout:maxedType="storage-buffer";maxedVisibility=4;extraType="storage-buffer";extraVisibility=4] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_pipeline_layout:maxedType="sampler";maxedVisibility=4;extraType="sampler";extraVisibility=4] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_bind_group_layout:maxedType="comparison-sampler";maxedVisibility=1;extraType="comparison-sampler";extraVisibility=4] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_bind_group_layout:maxedType="comparison-sampler";maxedVisibility=1;extraType="comparison-sampler";extraVisibility=2] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:visibility_and_dynamic_offsets:type="sampled-texture";hasDynamicOffset=true;visibility=3] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:visibility_and_dynamic_offsets:type="sampled-texture";hasDynamicOffset=true;visibility=2] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:visibility_and_dynamic_offsets:type="sampled-texture";hasDynamicOffset=true;visibility=1] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:visibility_and_dynamic_offsets:type="sampled-texture";hasDynamicOffset=true;visibility=0] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:visibility_and_dynamic_offsets:type="sampled-texture";hasDynamicOffset=true;visibility=7] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:visibility_and_dynamic_offsets:type="sampled-texture";hasDynamicOffset=true;visibility=6] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:visibility_and_dynamic_offsets:type="sampled-texture";hasDynamicOffset=true;visibility=5] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:visibility_and_dynamic_offsets:type="sampled-texture";hasDynamicOffset=true;visibility=4] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:visibility_and_dynamic_offsets:type="readonly-storage-texture";hasDynamicOffset=true;visibility=0] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:visibility_and_dynamic_offsets:type="readonly-storage-texture";hasDynamicOffset=true;visibility=1] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:visibility_and_dynamic_offsets:type="readonly-storage-texture";hasDynamicOffset=true;visibility=2] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:visibility_and_dynamic_offsets:type="readonly-storage-texture";hasDynamicOffset=true;visibility=3] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:visibility_and_dynamic_offsets:type="readonly-storage-texture";hasDynamicOffset=true;visibility=4] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:visibility_and_dynamic_offsets:type="readonly-storage-texture";hasDynamicOffset=true;visibility=5] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:visibility_and_dynamic_offsets:type="readonly-storage-texture";hasDynamicOffset=true;visibility=6] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:visibility_and_dynamic_offsets:type="readonly-storage-texture";hasDynamicOffset=true;visibility=7] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_pipeline_layout:maxedType="readonly-storage-buffer";maxedVisibility=2;extraType="storage-buffer";extraVisibility=2] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:texture_component_type:type="uniform-buffer";textureComponentType="float"] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:texture_component_type:type="sampler";textureComponentType="sint"] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:visibility_and_dynamic_offsets:type="storage-buffer";hasDynamicOffset=true;visibility=1] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:view_dimension:type="sampler";viewDimension="3d"] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:view_dimension:type="comparison-sampler";viewDimension="1d"] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:visibility_and_dynamic_offsets:type="storage-buffer";hasDynamicOffset=true;visibility=3] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:visibility_and_dynamic_offsets:type="storage-buffer";hasDynamicOffset=true;visibility=5] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:visibility_and_dynamic_offsets:type="storage-buffer";hasDynamicOffset=true;visibility=7] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_pipeline_layout:maxedType="sampled-texture";maxedVisibility=1;extraType="sampled-texture";extraVisibility=1] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_pipeline_layout:maxedType="readonly-storage-buffer";maxedVisibility=2;extraType="readonly-storage-buffer";extraVisibility=2] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_bind_group_layout:maxedType="writeonly-storage-texture";maxedVisibility=2;extraType="writeonly-storage-texture";extraVisibility=2] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_pipeline_layout:maxedType="uniform-buffer";maxedVisibility=4;extraType="uniform-buffer";extraVisibility=4] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_pipeline_layout:maxedType="comparison-sampler";maxedVisibility=2;extraType="comparison-sampler";extraVisibility=2] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_bind_group_layout:maxedType="sampler";maxedVisibility=1;extraType="comparison-sampler";extraVisibility=2] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_bind_group_layout:maxedType="uniform-buffer";maxedVisibility=4;extraType="uniform-buffer";extraVisibility=4] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:view_dimension:type="storage-buffer";viewDimension="cube-array"] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_bind_group_layout:maxedType="comparison-sampler";maxedVisibility=4;extraType="sampled-texture";extraVisibility=1] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_bind_group_layout:maxedType="comparison-sampler";maxedVisibility=4;extraType="sampled-texture";extraVisibility=2] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_bind_group_layout:maxedType="comparison-sampler";maxedVisibility=4;extraType="sampled-texture";extraVisibility=4] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:view_dimension:type="storage-buffer";viewDimension="2d-array"] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:view_dimension:type="readonly-storage-buffer";viewDimension="3d"] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_bind_group_layout:maxedType="comparison-sampler";maxedVisibility=2;extraType="sampled-texture";extraVisibility=2] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:visibility_and_dynamic_offsets:type="storage-buffer";hasDynamicOffset=false;visibility=7] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:visibility_and_dynamic_offsets:type="storage-buffer";hasDynamicOffset=false;visibility=5] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:visibility_and_dynamic_offsets:type="storage-buffer";hasDynamicOffset=false;visibility=3] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:visibility_and_dynamic_offsets:type="storage-buffer";hasDynamicOffset=false;visibility=1] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_pipeline_layout:maxedType="readonly-storage-buffer";maxedVisibility=4;extraType="storage-buffer";extraVisibility=4] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:storage_texture_format:type="readonly-storage-buffer";storageTextureFormat="rgba8unorm"] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:visibility_and_dynamic_offsets:type="comparison-sampler";hasDynamicOffset=true;visibility=7] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:visibility_and_dynamic_offsets:type="comparison-sampler";hasDynamicOffset=true;visibility=4] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:visibility_and_dynamic_offsets:type="comparison-sampler";hasDynamicOffset=true;visibility=5] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:visibility_and_dynamic_offsets:type="comparison-sampler";hasDynamicOffset=true;visibility=2] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:visibility_and_dynamic_offsets:type="comparison-sampler";hasDynamicOffset=true;visibility=3] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:visibility_and_dynamic_offsets:type="comparison-sampler";hasDynamicOffset=true;visibility=0] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:visibility_and_dynamic_offsets:type="comparison-sampler";hasDynamicOffset=true;visibility=1] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:multisampled:type="sampler";multisampled=true] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_bind_group_layout:maxedType="readonly-storage-buffer";maxedVisibility=2;extraType="readonly-storage-buffer";extraVisibility=2] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:view_dimension:type="comparison-sampler";viewDimension="3d"] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_pipeline_layout:maxedType="sampler";maxedVisibility=2;extraType="sampler";extraVisibility=2] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_bind_group_layout:maxedType="sampler";maxedVisibility=1;extraType="sampled-texture";extraVisibility=2] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_bind_group_layout:maxedType="sampler";maxedVisibility=1;extraType="sampled-texture";extraVisibility=1] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_bind_group_layout:maxedType="sampler";maxedVisibility=1;extraType="sampled-texture";extraVisibility=4] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_bind_group_layout:maxedType="sampled-texture";maxedVisibility=1;extraType="sampler";extraVisibility=2] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:view_dimension:type="uniform-buffer";viewDimension="1d"] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_bind_group_layout:maxedType="sampled-texture";maxedVisibility=1;extraType="sampler";extraVisibility=1] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_bind_group_layout:maxedType="sampled-texture";maxedVisibility=1;extraType="sampler";extraVisibility=4] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_bind_group_layout:maxedType="storage-buffer";maxedVisibility=4;extraType="readonly-storage-buffer";extraVisibility=4] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:texture_component_type:type="comparison-sampler";textureComponentType="uint"] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_pipeline_layout:maxedType="writeonly-storage-texture";maxedVisibility=4;extraType="writeonly-storage-texture";extraVisibility=4] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_pipeline_layout:maxedType="readonly-storage-buffer";maxedVisibility=4;extraType="readonly-storage-buffer";extraVisibility=4] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:multisampled:type="writeonly-storage-texture";multisampled=undefined] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_bind_group_layout:maxedType="sampled-texture";maxedVisibility=4;extraType="sampler";extraVisibility=4] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_bind_group_layout:maxedType="sampled-texture";maxedVisibility=4;extraType="sampler";extraVisibility=2] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_bind_group_layout:maxedType="sampled-texture";maxedVisibility=4;extraType="sampler";extraVisibility=1] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:multisampled:type="storage-buffer";multisampled=true] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_pipeline_layout:maxedType="storage-buffer";maxedVisibility=2;extraType="storage-buffer";extraVisibility=2] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_bind_group_layout:maxedType="comparison-sampler";maxedVisibility=1;extraType="sampler";extraVisibility=4] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_bind_group_layout:maxedType="comparison-sampler";maxedVisibility=1;extraType="sampler";extraVisibility=2] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:view_dimension:type="storage-buffer";viewDimension="1d"] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_bind_group_layout:maxedType="storage-buffer";maxedVisibility=2;extraType="readonly-storage-buffer";extraVisibility=2] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_pipeline_layout:maxedType="writeonly-storage-texture";maxedVisibility=2;extraType="writeonly-storage-texture";extraVisibility=2] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_bind_group_layout:maxedType="readonly-storage-texture";maxedVisibility=2;extraType="writeonly-storage-texture";extraVisibility=2] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_bind_group_layout:maxedType="writeonly-storage-texture";maxedVisibility=2;extraType="readonly-storage-texture";extraVisibility=2] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_bind_group_layout:maxedType="writeonly-storage-texture";maxedVisibility=4;extraType="readonly-storage-texture";extraVisibility=4] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_bind_group_layout:maxedType="readonly-storage-texture";maxedVisibility=2;extraType="readonly-storage-texture";extraVisibility=2] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_bind_group_layout:maxedType="readonly-storage-texture";maxedVisibility=4;extraType="readonly-storage-texture";extraVisibility=4] + expected: FAIL + + [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_bind_group_layout:maxedType="readonly-storage-texture";maxedVisibility=4;extraType="writeonly-storage-texture";extraVisibility=4] + expected: FAIL + + +[cts.html?q=webgpu:api,operation,command_buffer,copies:*] + [webgpu:api,operation,command_buffer,copies:b2t2b:] + expected: FAIL + + [webgpu:api,operation,command_buffer,copies:b2t2t2b:] + expected: FAIL + + [webgpu:api,operation,command_buffer,copies:b2b:] + expected: FAIL + + +[cts.html?q=webgpu:api,validation,createBindGroup:*] + expected: CRASH + +[cts.html?q=webgpu:api,operation,fences:*] + [webgpu:api,operation,fences:wait,many,serially:] + expected: FAIL + + [webgpu:api,operation,fences:initial,descriptor_with_initialValue:] + expected: FAIL + + [webgpu:api,operation,fences:wait,equal_to_signaled:] + expected: FAIL + + [webgpu:api,operation,fences:drop,promise:] + expected: FAIL + + [webgpu:api,operation,fences:wait,less_than_signaled:] + expected: FAIL + + [webgpu:api,operation,fences:wait,resolves_within_timeout:] + expected: FAIL + + [webgpu:api,operation,fences:wait,already_completed:] + expected: FAIL + + [webgpu:api,operation,fences:drop,fence_and_promise:] + expected: FAIL + + [webgpu:api,operation,fences:wait,many,parallel:] + expected: FAIL + + [webgpu:api,operation,fences:initial,empty_descriptor:] + expected: FAIL + + [webgpu:api,operation,fences:initial,no_descriptor:] + expected: FAIL + + [webgpu:api,operation,fences:wait,signaled_multiple_times:] + expected: FAIL + + [webgpu:api,operation,fences:wait,signaled_once:] + expected: FAIL + + +[cts.html?q=webgpu:api,validation,setStencilReference:*] + +[cts.html?q=webgpu:api,validation,setBlendColor:*] + +[cts.html?q=webgpu:api,validation,render_pass_descriptor:*] + expected: CRASH + [webgpu:api,validation,render_pass_descriptor:check_the_use_of_multisampled_textures_as_color_attachments:] + expected: FAIL + + [webgpu:api,validation,render_pass_descriptor:check_mip_level_count_for_color_or_depth_stencil:mipLevelCount=2;baseMipLevel=0] + expected: FAIL + + [webgpu:api,validation,render_pass_descriptor:it_is_invalid_to_use_a_resolve_target_with_array_layer_count_greater_than_1:] + expected: FAIL + + [webgpu:api,validation,render_pass_descriptor:use_a_resolve_target_in_a_format_different_than_the_attachment_is_not_allowed:] + expected: FAIL + + [webgpu:api,validation,render_pass_descriptor:it_is_invalid_to_use_a_resolve_target_in_error_state:] + expected: FAIL + + [webgpu:api,validation,render_pass_descriptor:size_of_the_resolve_target_must_be_the_same_as_the_color_attachment:] + expected: FAIL + + [webgpu:api,validation,render_pass_descriptor:attachments_must_have_the_same_size:] + expected: FAIL + + [webgpu:api,validation,render_pass_descriptor:check_layer_count_for_color_or_depth_stencil:arrayLayerCount=5;baseArrayLayer=0] + expected: FAIL + + [webgpu:api,validation,render_pass_descriptor:it_is_invalid_to_use_a_resolve_target_with_mipmap_level_count_greater_than_1:] + expected: FAIL + + [webgpu:api,validation,render_pass_descriptor:it_is_invalid_to_set_resolve_target_if_color_attachment_is_non_multisampled:] + expected: FAIL + + [webgpu:api,validation,render_pass_descriptor:OOB_color_attachment_indices_are_handled:colorAttachmentsCount=5] + expected: FAIL + + [webgpu:api,validation,render_pass_descriptor:attachments_must_match_whether_they_are_used_for_color_or_depth_stencil:] + expected: FAIL + + [webgpu:api,validation,render_pass_descriptor:it_is_invalid_to_use_a_multisampled_resolve_target:] + expected: FAIL + + [webgpu:api,validation,render_pass_descriptor:it_is_invalid_to_use_a_resolve_target_whose_usage_is_not_output_attachment:] + expected: FAIL + + [webgpu:api,validation,render_pass_descriptor:check_depth_stencil_attachment_sample_counts_mismatch:] + expected: FAIL + + +[cts.html?q=webgpu:examples:*] + [webgpu:examples:gpu,async:] + expected: FAIL + + [webgpu:examples:gpu,buffers:] + expected: FAIL + + +[cts.html?q=webgpu:api,operation,render_pass,storeOp:*] + expected: ERROR + +[cts.html?q=webgpu:api,operation,resource_init,depth_stencil_attachment_clear:*] + expected: CRASH + +[cts.html?q=webgpu:api,operation,buffers,map_detach:*] + [webgpu:api,operation,buffers,map_detach:create_mapped:unmap=false;destroy=true] + expected: FAIL + + [webgpu:api,operation,buffers,map_detach:create_mapped:unmap=true;destroy=false] + expected: FAIL + + [webgpu:api,operation,buffers,map_detach:mapReadAsync:unmap=true;destroy=true] + expected: FAIL + + [webgpu:api,operation,buffers,map_detach:mapWriteAsync:unmap=true;destroy=false] + expected: FAIL + + [webgpu:api,operation,buffers,map_detach:mapWriteAsync:unmap=false;destroy=true] + expected: FAIL + + [webgpu:api,operation,buffers,map_detach:mapWriteAsync:unmap=true;destroy=true] + expected: FAIL + + [webgpu:api,operation,buffers,map_detach:mapReadAsync:unmap=false;destroy=true] + expected: FAIL + + [webgpu:api,operation,buffers,map_detach:create_mapped:unmap=true;destroy=true] + expected: FAIL + + [webgpu:api,operation,buffers,map_detach:mapReadAsync:unmap=true;destroy=false] + expected: FAIL + + +[cts.html?q=webgpu:api,operation,command_buffer,basic:*] + +[cts.html?q=webgpu:api,operation,render_pipeline,culling_tests:*] + [webgpu:api,operation,render_pipeline,culling_tests:culling:frontFace="cw";cullMode="none";depthStencilFormat="depth24plus";primitiveTopology="triangle-list"] + expected: FAIL + + [webgpu:api,operation,render_pipeline,culling_tests:culling:frontFace="cw";cullMode="back";depthStencilFormat="depth32float";primitiveTopology="triangle-list"] + expected: FAIL + + [webgpu:api,operation,render_pipeline,culling_tests:culling:frontFace="ccw";cullMode="none";depthStencilFormat="depth24plus";primitiveTopology="triangle-list"] + expected: FAIL + + [webgpu:api,operation,render_pipeline,culling_tests:culling:frontFace="ccw";cullMode="none";depthStencilFormat="depth32float";primitiveTopology="triangle-list"] + expected: FAIL + + [webgpu:api,operation,render_pipeline,culling_tests:culling:frontFace="cw";cullMode="back";depthStencilFormat=null;primitiveTopology="triangle-list"] + expected: FAIL + + [webgpu:api,operation,render_pipeline,culling_tests:culling:frontFace="ccw";cullMode="back";depthStencilFormat="depth24plus";primitiveTopology="triangle-list"] + expected: FAIL + + [webgpu:api,operation,render_pipeline,culling_tests:culling:frontFace="cw";cullMode="front";depthStencilFormat=null;primitiveTopology="triangle-list"] + expected: FAIL + + [webgpu:api,operation,render_pipeline,culling_tests:culling:frontFace="ccw";cullMode="front";depthStencilFormat="depth24plus";primitiveTopology="triangle-list"] + expected: FAIL + + [webgpu:api,operation,render_pipeline,culling_tests:culling:frontFace="ccw";cullMode="front";depthStencilFormat=null;primitiveTopology="triangle-list"] + expected: FAIL + + [webgpu:api,operation,render_pipeline,culling_tests:culling:frontFace="ccw";cullMode="back";depthStencilFormat=null;primitiveTopology="triangle-list"] + expected: FAIL + + [webgpu:api,operation,render_pipeline,culling_tests:culling:frontFace="cw";cullMode="front";depthStencilFormat="depth24plus";primitiveTopology="triangle-list"] + expected: FAIL + + [webgpu:api,operation,render_pipeline,culling_tests:culling:frontFace="cw";cullMode="front";depthStencilFormat="depth24plus-stencil8";primitiveTopology="triangle-list"] + expected: FAIL + + [webgpu:api,operation,render_pipeline,culling_tests:culling:frontFace="cw";cullMode="front";depthStencilFormat="depth32float";primitiveTopology="triangle-list"] + expected: FAIL + + [webgpu:api,operation,render_pipeline,culling_tests:culling:frontFace="cw";cullMode="none";depthStencilFormat="depth24plus-stencil8";primitiveTopology="triangle-list"] + expected: FAIL + + [webgpu:api,operation,render_pipeline,culling_tests:culling:frontFace="cw";cullMode="back";depthStencilFormat="depth24plus-stencil8";primitiveTopology="triangle-list"] + expected: FAIL + + [webgpu:api,operation,render_pipeline,culling_tests:culling:frontFace="ccw";cullMode="none";depthStencilFormat=null;primitiveTopology="triangle-list"] + expected: FAIL + + [webgpu:api,operation,render_pipeline,culling_tests:culling:frontFace="cw";cullMode="none";depthStencilFormat=null;primitiveTopology="triangle-list"] + expected: FAIL + + [webgpu:api,operation,render_pipeline,culling_tests:culling:frontFace="ccw";cullMode="none";depthStencilFormat="depth24plus-stencil8";primitiveTopology="triangle-list"] + expected: FAIL + + [webgpu:api,operation,render_pipeline,culling_tests:culling:frontFace="ccw";cullMode="front";depthStencilFormat="depth32float";primitiveTopology="triangle-list"] + expected: FAIL + + [webgpu:api,operation,render_pipeline,culling_tests:culling:frontFace="ccw";cullMode="back";depthStencilFormat="depth32float";primitiveTopology="triangle-list"] + expected: FAIL + + [webgpu:api,operation,render_pipeline,culling_tests:culling:frontFace="ccw";cullMode="front";depthStencilFormat="depth24plus-stencil8";primitiveTopology="triangle-list"] + expected: FAIL + + [webgpu:api,operation,render_pipeline,culling_tests:culling:frontFace="cw";cullMode="back";depthStencilFormat="depth24plus";primitiveTopology="triangle-list"] + expected: FAIL + + [webgpu:api,operation,render_pipeline,culling_tests:culling:frontFace="cw";cullMode="none";depthStencilFormat="depth32float";primitiveTopology="triangle-list"] + expected: FAIL + + [webgpu:api,operation,render_pipeline,culling_tests:culling:frontFace="ccw";cullMode="back";depthStencilFormat="depth24plus-stencil8";primitiveTopology="triangle-list"] + expected: FAIL + + +[cts.html?q=webgpu:api,validation,queue_submit:*] + [webgpu:api,validation,queue_submit:submitting_with_a_mapped_buffer_is_disallowed:] + expected: FAIL + + +[cts.html?q=webgpu:api,operation,resource_init,sampled_texture_clear:*] + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r8uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg32uint";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba32float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r32float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg32uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r16uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba16float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba32uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba16uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg8sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgb10a2unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg16sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm-srgb";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg16sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg16float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba32float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg32uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm-srgb";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r16sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm-srgb";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r32sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgb10a2unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r16uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm-srgb";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r16float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r32sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba32sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg8unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r16sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r32uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r8unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r8uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba8uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r8uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg8uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba8sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba16float";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r8unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba8snorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba8sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r32uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg16float";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg16float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg8snorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba8sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba8sint";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg8unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgb10a2unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba32uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba32uint";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg8snorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg16uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgb10a2unorm";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg32sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg32uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba8snorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r32uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm-srgb";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg8sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r16uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg8sint";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba32uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r8sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r16sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r32float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba16float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r16uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r8uint";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r16float";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r32uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg32float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r16uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm-srgb";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba8sint";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg16sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r8sint";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r16sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r32float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg8snorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg32sint";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg32sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r8unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm-srgb";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r16float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm-srgb";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba8snorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba32float";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg8sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg8unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg16sint";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg8unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg16float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm-srgb";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba8sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg16float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba16uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg11b10float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg32sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg8unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg16float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg8unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg32float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba16float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba16sint";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r32uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r16sint";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r16float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r16uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba8sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm-srgb";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg8uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba8sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r32uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba16uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm-srgb";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba16uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgb10a2unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg8uint";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg16sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba32uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg16sint";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm-srgb";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba32float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm-srgb";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg8unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r32float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg16uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgb10a2unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm-srgb";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba32float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba16sint";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg32uint";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r16sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba32float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r8sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm-srgb";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba16float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r8uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r32uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg32float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba32uint";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba16float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r8unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba16sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba16uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg11b10float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r32float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm-srgb";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg16uint";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba32float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg8sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r32uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg8unorm";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg32uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba16sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r32sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg8sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg32float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg8uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg16uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba8sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg32uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg32sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba8uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg8sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg16float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r32sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba32sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgb10a2unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm-srgb";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r16sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r16uint";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg16sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg8sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm-srgb";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba16uint";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r32sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg8snorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r8sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r8snorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba8uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r8sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba32float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg16uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba8uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba32sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r16sint";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg8uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg32float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg16sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg8uint";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r32uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba16sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r8unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg16uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r32float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg32float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r32uint";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg32uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r16float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba32uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg32uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba16float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r16float";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg16uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba32float";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r8sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg32sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg16sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg16float";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r8sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r8snorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r32sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg8unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r8snorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r8unorm";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r16sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r8unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg8unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm-srgb";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba32uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r8sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba8sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r16sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba16float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba16uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba16float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r32uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r16uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg8unorm";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba8uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r8sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba32uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba16float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg16sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg32uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg32sint";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg16uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba32uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba32uint";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r8uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba8uint";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg8uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg16float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r8uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r16float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg8snorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba32float";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm-srgb";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg16sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg32sint";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm-srgb";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r8unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgb10a2unorm";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r32sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba32sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg8unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r16sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg32uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r8uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba32sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg8sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r32sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba16sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg32float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba16uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r16sint";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgb10a2unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r32float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r16float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg8sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r16uint";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba32uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba32float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg32float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba16sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r32uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba16sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg32sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r16sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r8snorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg32float";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r8unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg8sint";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg8unorm";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgb10a2unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r16float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r8uint";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r8snorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba32sint";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba16sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg16float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg8sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba16sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg32uint";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg32sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r8uint";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba32sint";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg32float";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r8sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg16uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg16float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r32float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg32sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba16sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r16sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r32float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r8unorm";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm-srgb";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r32sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm-srgb";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg16float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg16uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg16sint";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r16float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg16sint";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba16uint";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg16sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r16float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg11b10float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg16float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg8uint";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r16sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r32sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg16uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg32float";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba8sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba32uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r32sint";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba32sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg16uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg32uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba16uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r8sint";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r32uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba32uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg16sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r16uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg32uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r32float";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba32uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg11b10float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba8sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg32float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg32sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba8snorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r8snorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba16sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r8sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg32sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg16uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg11b10float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba32sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba32uint";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r16float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg32sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba16uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg32float";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba8uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg32uint";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg8uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg16float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgb10a2unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r32uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba32uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r16uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg32sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg16uint";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r8uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg32uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r32sint";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r8uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r8unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba16float";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba32float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg8sint";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba32sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r32float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r16sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r32uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgb10a2unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg8sint";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgb10a2unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg32sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba32sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba32uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm-srgb";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg16float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r8sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba16sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba8sint";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r8sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg32float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba8uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm-srgb";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg8unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg11b10float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba16sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg32sint";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba32float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r32uint";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r16float";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba16uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg16float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba32sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg32float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r8uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba8uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r16float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r32sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r8uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r32sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r8unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg8uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm-srgb";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba8sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg8uint";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba16sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg16sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm-srgb";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba8sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg16float";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm-srgb";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r16uint";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm-srgb";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm-srgb";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba8snorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg8uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg32uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg8uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg16uint";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba32sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r16float";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba8uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg32uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r8sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r32float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r32float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg8uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba16uint";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r16sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg8sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg8snorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba8uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba32float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba16float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r8uint";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba32sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r32float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba8sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg16float";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm-srgb";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r8unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg8unorm";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba8sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r16float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r8sint";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgb10a2unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba16sint";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg16uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r16sint";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba16float";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm-srgb";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r32uint";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg8uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r8sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba32sint";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgb10a2unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r32sint";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r32sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba8uint";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg16uint";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg16sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba16sint";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r8uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg8sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba32sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba16sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r8unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r32sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba8uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg32sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r32sint";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba32sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r32uint";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba8uint";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r32float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg32uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba32uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r8unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba32float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r8uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg16uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba32float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgb10a2unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg8unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg8unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r8sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r8unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba32float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r8uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg16float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg8uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm-srgb";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r16float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba8uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r32float";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba32sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba8sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba8uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r16uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg8uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm-srgb";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba8snorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg32sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r16sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba8uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba32sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r16uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba8sint";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgb10a2unorm";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg8sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba16uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm-srgb";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r32float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg32float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba16float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba16float";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba16uint";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r16uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba32float";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg8unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r16float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r32float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r16sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r32sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg16sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg8uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r8unorm";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r16uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg32sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg32float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg8sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r16uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg8snorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba32float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba8snorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba16float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg8snorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba8sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg8uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg32float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba16float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r8uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg16uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r16float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg16uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r8unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm-srgb";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg8sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba16uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba16uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba16float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg8unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm-srgb";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba16sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r8sint";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r16uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba16uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg8sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba32uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg11b10float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r16uint";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r8sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg11b10float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r32float";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r8snorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r16float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg16float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba32sint";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba16sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba16uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg32float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r32uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba16float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r8unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm-srgb";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r8unorm";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r8uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba8uint";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg32float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r16uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r32sint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba8snorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba16float";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg8uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r8snorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgb10a2unorm";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r32uint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg32uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm-srgb";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgb10a2unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba8unorm";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg8unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg16sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba8uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba32float";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgb10a2unorm";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba8uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rg16sint";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm-srgb";aspect="all";mipLevelCount=5;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=true] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="r32float";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="rgba16uint";aspect="all";mipLevelCount=1;sampleCount=1;uninitializeMethod="Creation";readMethod="Sample";dimension="2d";sliceCount=7;nonPowerOfTwo=false] + expected: FAIL + + [webgpu:api,operation,resource_init,sampled_texture_clear:uninitialized_texture_is_zero:format="bgra8unorm";aspect="all";mipLevelCount=1;sampleCount=4;uninitializeMethod="StoreOpClear";readMethod="Sample";dimension="2d";sliceCount=1;nonPowerOfTwo=false] + expected: FAIL + + +[cts.html?q=webgpu:api,validation,vertex_state:*] + [webgpu:api,validation,vertex_state:pipeline_vertex_buffers_are_backed_by_attributes_in_vertex_input:] + expected: FAIL + + [webgpu:api,validation,vertex_state:offset_should_be_within_vertex_buffer_arrayStride_if_arrayStride_is_not_zero:] + expected: FAIL + + [webgpu:api,validation,vertex_state:check_out_of_bounds_on_number_of_vertex_attributes_across_vertex_buffers:] + expected: FAIL + + [webgpu:api,validation,vertex_state:check_out_of_bounds_condition_on_input_strides:] + expected: FAIL + + [webgpu:api,validation,vertex_state:we_cannot_set_same_shader_location:] + expected: FAIL + + [webgpu:api,validation,vertex_state:check_attribute_offset_out_of_bounds:] + expected: FAIL + + [webgpu:api,validation,vertex_state:check_out_of_bounds_condition_on_attribute_shader_location:] + expected: FAIL + + [webgpu:api,validation,vertex_state:check_out_of_bounds_on_number_of_vertex_attributes_on_a_single_vertex_buffer:] + expected: FAIL + + [webgpu:api,validation,vertex_state:check_multiple_of_4_bytes_constraint_on_offset:] + expected: FAIL + + [webgpu:api,validation,vertex_state:identical_duplicate_attributes_are_invalid:] + expected: FAIL + + [webgpu:api,validation,vertex_state:check_out_of_bounds_condition_on_total_number_of_vertex_buffers:] + expected: FAIL + + +[cts.html?q=webgpu:api,validation,fences:*] + [webgpu:api,validation,fences:signal_a_fence_on_a_different_device_does_not_update_fence_signaled_value:] + expected: FAIL + + [webgpu:api,validation,fences:wait_on_a_fence_with_a_value_greater_than_signaled_value_is_invalid:] + expected: FAIL + + [webgpu:api,validation,fences:wait_on_a_fence_without_signaling_the_value_is_invalid:] + expected: FAIL + + [webgpu:api,validation,fences:signal_a_fence_on_a_different_device_than_it_was_created_on_is_invalid:] + expected: FAIL + + [webgpu:api,validation,fences:signal_a_value_equal_to_signaled_value_is_invalid:] + expected: FAIL + + [webgpu:api,validation,fences:increasing_fence_value_by_more_than_1_succeeds:] + expected: FAIL + + [webgpu:api,validation,fences:signal_a_value_lower_than_signaled_value_is_invalid:] + expected: FAIL + + +[cts.html?q=webgpu:api,validation,setScissorRect:*] + [webgpu:api,validation,setScissorRect:use_of_setScissorRect:x=0;y=0;width=0;height=1] + expected: FAIL + + [webgpu:api,validation,setScissorRect:use_of_setScissorRect:x=0;y=0;width=0;height=0] + expected: FAIL + + [webgpu:api,validation,setScissorRect:use_of_setScissorRect:x=0;y=0;width=1;height=0] + expected: FAIL + + +[cts.html?q=webgpu:shader,execution,robust_access_vertex:*] + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="vertexCount";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec3";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstInstance";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstInstance";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="indexCount";type="float";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="indexCount";type="vec2";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec3";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=100] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="float";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstIndex";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="firstVertex";type="float";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="baseVertex";type="vec2";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="firstVertex";type="vec3";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="instanceCount";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=true;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec4";additionalBuffers=4;partialLastNumber=false;offsetVertexBuffer=false;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=false;indirect=false;drawCallTestParameter="vertexCount";type="vec4";additionalBuffers=0;partialLastNumber=true;offsetVertexBuffer=true;errorScale=10000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="firstIndex";type="vec4";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=false;errorScale=1] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="firstInstance";type="float";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=true;errorScale=4] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=true;drawCallTestParameter="baseVertex";type="vec3";additionalBuffers=0;partialLastNumber=false;offsetVertexBuffer=true;errorScale=1000000] + expected: FAIL + + [webgpu:shader,execution,robust_access_vertex:vertexAccess:indexed=true;indirect=false;drawCallTestParameter="instanceCount";type="vec2";additionalBuffers=4;partialLastNumber=true;offsetVertexBuffer=false;errorScale=1000000] + expected: FAIL + + +[cts.html?q=webgpu:api,validation,encoding,cmds,index_access:*] + [webgpu:api,validation,encoding,cmds,index_access:out_of_bounds:indirect=true;indexCount=10000;firstIndex=0;instanceCount=1] + expected: FAIL + + [webgpu:api,validation,encoding,cmds,index_access:out_of_bounds:indirect=false;indexCount=6;firstIndex=1;instanceCount=10000] + expected: FAIL + + [webgpu:api,validation,encoding,cmds,index_access:out_of_bounds:indirect=true;indexCount=6;firstIndex=6;instanceCount=10000] + expected: FAIL + + [webgpu:api,validation,encoding,cmds,index_access:out_of_bounds:indirect=true;indexCount=6;firstIndex=1;instanceCount=1] + expected: FAIL + + [webgpu:api,validation,encoding,cmds,index_access:out_of_bounds:indirect=false;indexCount=6;firstIndex=6;instanceCount=1] + expected: FAIL + + [webgpu:api,validation,encoding,cmds,index_access:out_of_bounds:indirect=false;indexCount=6;firstIndex=10000;instanceCount=10000] + expected: FAIL + + [webgpu:api,validation,encoding,cmds,index_access:out_of_bounds:indirect=false;indexCount=7;firstIndex=0;instanceCount=1] + expected: FAIL + + [webgpu:api,validation,encoding,cmds,index_access:out_of_bounds:indirect=false;indexCount=6;firstIndex=6;instanceCount=10000] + expected: FAIL + + [webgpu:api,validation,encoding,cmds,index_access:out_of_bounds:indirect=true;indexCount=7;firstIndex=0;instanceCount=1] + expected: FAIL + + [webgpu:api,validation,encoding,cmds,index_access:out_of_bounds:indirect=false;indexCount=10000;firstIndex=0;instanceCount=10000] + expected: FAIL + + [webgpu:api,validation,encoding,cmds,index_access:out_of_bounds:indirect=false;indexCount=10000;firstIndex=0;instanceCount=1] + expected: FAIL + + [webgpu:api,validation,encoding,cmds,index_access:out_of_bounds:indirect=true;indexCount=6;firstIndex=1;instanceCount=10000] + expected: FAIL + + [webgpu:api,validation,encoding,cmds,index_access:out_of_bounds:indirect=false;indexCount=6;firstIndex=10000;instanceCount=1] + expected: FAIL + + [webgpu:api,validation,encoding,cmds,index_access:out_of_bounds:indirect=false;indexCount=7;firstIndex=0;instanceCount=10000] + expected: FAIL + + [webgpu:api,validation,encoding,cmds,index_access:out_of_bounds:indirect=true;indexCount=6;firstIndex=10000;instanceCount=1] + expected: FAIL + + [webgpu:api,validation,encoding,cmds,index_access:out_of_bounds:indirect=true;indexCount=10000;firstIndex=0;instanceCount=10000] + expected: FAIL + + [webgpu:api,validation,encoding,cmds,index_access:out_of_bounds:indirect=true;indexCount=7;firstIndex=0;instanceCount=10000] + expected: FAIL + + [webgpu:api,validation,encoding,cmds,index_access:out_of_bounds:indirect=true;indexCount=6;firstIndex=10000;instanceCount=10000] + expected: FAIL + + [webgpu:api,validation,encoding,cmds,index_access:out_of_bounds:indirect=false;indexCount=6;firstIndex=1;instanceCount=1] + expected: FAIL + + [webgpu:api,validation,encoding,cmds,index_access:out_of_bounds:indirect=true;indexCount=6;firstIndex=6;instanceCount=1] + expected: FAIL + + +[cts.html?q=webgpu:web-platform,canvas,context_creation:*] + +[cts.html?q=webgpu:api,validation,setBindGroup:*] + [webgpu:api,validation,setBindGroup:dynamic_offsets_match_expectations_in_pass_encoder:type="compute";dynamicOffsets=[0,4294967295\]] + expected: FAIL + + [webgpu:api,validation,setBindGroup:dynamic_offsets_match_expectations_in_pass_encoder:type="renderbundle";dynamicOffsets=[1024,0\]] + expected: FAIL + + [webgpu:api,validation,setBindGroup:dynamic_offsets_match_expectations_in_pass_encoder:type="renderpass";dynamicOffsets=[0,4294967295\]] + expected: FAIL + + [webgpu:api,validation,setBindGroup:dynamic_offsets_match_expectations_in_pass_encoder:type="renderpass";dynamicOffsets=[\]] + expected: FAIL + + [webgpu:api,validation,setBindGroup:dynamic_offsets_match_expectations_in_pass_encoder:type="renderpass";dynamicOffsets=[1,2\]] + expected: FAIL + + [webgpu:api,validation,setBindGroup:dynamic_offsets_match_expectations_in_pass_encoder:type="compute";dynamicOffsets=[0,1024\]] + expected: FAIL + + [webgpu:api,validation,setBindGroup:dynamic_offsets_match_expectations_in_pass_encoder:type="renderpass";dynamicOffsets=[0,512\]] + expected: FAIL + + [webgpu:api,validation,setBindGroup:dynamic_offsets_match_expectations_in_pass_encoder:type="renderbundle";dynamicOffsets=[4294967295,0\]] + expected: FAIL + + [webgpu:api,validation,setBindGroup:dynamic_offsets_match_expectations_in_pass_encoder:type="compute";dynamicOffsets=[4294967295,0\]] + expected: FAIL + + [webgpu:api,validation,setBindGroup:dynamic_offsets_passed_but_not_expected,compute_pass:type="renderpass"] + expected: FAIL + + [webgpu:api,validation,setBindGroup:dynamic_offsets_match_expectations_in_pass_encoder:type="compute";dynamicOffsets=[256\]] + expected: FAIL + + [webgpu:api,validation,setBindGroup:dynamic_offsets_match_expectations_in_pass_encoder:type="compute";dynamicOffsets=[0,512\]] + expected: FAIL + + [webgpu:api,validation,setBindGroup:dynamic_offsets_match_expectations_in_pass_encoder:type="compute";dynamicOffsets=[1,2\]] + expected: FAIL + + [webgpu:api,validation,setBindGroup:dynamic_offsets_match_expectations_in_pass_encoder:type="renderbundle";dynamicOffsets=[0,4294967295\]] + expected: FAIL + + [webgpu:api,validation,setBindGroup:dynamic_offsets_match_expectations_in_pass_encoder:type="renderpass";dynamicOffsets=[256,0,0\]] + expected: FAIL + + [webgpu:api,validation,setBindGroup:dynamic_offsets_match_expectations_in_pass_encoder:type="renderbundle";dynamicOffsets=[\]] + expected: FAIL + + [webgpu:api,validation,setBindGroup:dynamic_offsets_match_expectations_in_pass_encoder:type="compute";dynamicOffsets=[256,0,0\]] + expected: FAIL + + [webgpu:api,validation,setBindGroup:dynamic_offsets_match_expectations_in_pass_encoder:type="renderpass";dynamicOffsets=[4294967295,0\]] + expected: FAIL + + [webgpu:api,validation,setBindGroup:dynamic_offsets_match_expectations_in_pass_encoder:type="renderbundle";dynamicOffsets=[0,512\]] + expected: FAIL + + [webgpu:api,validation,setBindGroup:dynamic_offsets_match_expectations_in_pass_encoder:type="renderbundle";dynamicOffsets=[0,1024\]] + expected: FAIL + + [webgpu:api,validation,setBindGroup:dynamic_offsets_match_expectations_in_pass_encoder:type="compute";dynamicOffsets=[\]] + expected: FAIL + + [webgpu:api,validation,setBindGroup:dynamic_offsets_match_expectations_in_pass_encoder:type="renderpass";dynamicOffsets=[256\]] + expected: FAIL + + [webgpu:api,validation,setBindGroup:dynamic_offsets_match_expectations_in_pass_encoder:type="renderbundle";dynamicOffsets=[256,0,0\]] + expected: FAIL + + [webgpu:api,validation,setBindGroup:dynamic_offsets_match_expectations_in_pass_encoder:type="renderbundle";dynamicOffsets=[1,2\]] + expected: FAIL + + [webgpu:api,validation,setBindGroup:dynamic_offsets_match_expectations_in_pass_encoder:type="renderpass";dynamicOffsets=[512,0\]] + expected: FAIL + + [webgpu:api,validation,setBindGroup:dynamic_offsets_match_expectations_in_pass_encoder:type="compute";dynamicOffsets=[1024,0\]] + expected: FAIL + + [webgpu:api,validation,setBindGroup:dynamic_offsets_match_expectations_in_pass_encoder:type="renderbundle";dynamicOffsets=[512,0\]] + expected: FAIL + + [webgpu:api,validation,setBindGroup:dynamic_offsets_match_expectations_in_pass_encoder:type="renderpass";dynamicOffsets=[1024,0\]] + expected: FAIL + + [webgpu:api,validation,setBindGroup:dynamic_offsets_passed_but_not_expected,compute_pass:type="compute"] + expected: FAIL + + [webgpu:api,validation,setBindGroup:dynamic_offsets_match_expectations_in_pass_encoder:type="compute";dynamicOffsets=[512,0\]] + expected: FAIL + + [webgpu:api,validation,setBindGroup:dynamic_offsets_match_expectations_in_pass_encoder:type="renderpass";dynamicOffsets=[0,1024\]] + expected: FAIL + + [webgpu:api,validation,setBindGroup:dynamic_offsets_match_expectations_in_pass_encoder:type="renderbundle";dynamicOffsets=[256\]] + expected: FAIL + + +[cts.html?q=webgpu:api,operation,command_buffer,render,rendering:*] + [webgpu:api,operation,command_buffer,render,rendering:fullscreen_quad:] + expected: FAIL + + +[cts.html?q=webgpu:api,operation,buffers,create_mapped:*] + [webgpu:api,operation,buffers,create_mapped:createBufferMapped:size=12;mappable=true] + expected: FAIL + + [webgpu:api,operation,buffers,create_mapped:createBufferMapped:size=524288;mappable=true] + expected: FAIL + + [webgpu:api,operation,buffers,create_mapped:createBufferMapped:size=524288;mappable=false] + expected: FAIL + + [webgpu:api,operation,buffers,create_mapped:createBufferMapped:size=12;mappable=false] + expected: FAIL + + +[cts.html?q=webgpu:api,validation,createView:*] + [webgpu:api,validation,createView:Using_defaults_validates_the_same_as_setting_values_for_more_than_1_array_layer:dimension="2d"] + expected: FAIL + + [webgpu:api,validation,createView:Using_defaults_validates_the_same_as_setting_values_for_more_than_1_array_layer:arrayLayerCount=6] + expected: FAIL + + [webgpu:api,validation,createView:creating_cube_map_texture_view:dimension="cube"] + expected: FAIL + + [webgpu:api,validation,createView:it_is_invalid_to_use_a_texture_view_created_from_a_destroyed_texture:] + expected: FAIL + + [webgpu:api,validation,createView:test_the_format_compatibility_rules_when_creating_a_texture_view:] + expected: FAIL + + [webgpu:api,validation,createView:creating_cube_map_texture_view:dimension="cube";arrayLayerCount=12] + expected: FAIL + + [webgpu:api,validation,createView:Using_defaults_validates_the_same_as_setting_values_for_more_than_1_array_layer:format="r8unorm"] + expected: FAIL + + [webgpu:api,validation,createView:Using_defaults_validates_the_same_as_setting_values_for_only_1_array_layer:format="r8unorm"] + expected: FAIL + + [webgpu:api,validation,createView:creating_cube_map_texture_view:dimension="cube";arrayLayerCount=3] + expected: FAIL + + [webgpu:api,validation,createView:creating_cube_map_texture_view:dimension="cube";arrayLayerCount=7] + expected: FAIL + + [webgpu:api,validation,createView:creating_cube_map_texture_view:dimension="cube-array";arrayLayerCount=13] + expected: FAIL + + [webgpu:api,validation,createView:creating_cube_map_texture_view:dimension="cube-array";arrayLayerCount=11] + expected: FAIL + + [webgpu:api,validation,createView:creating_cube_map_texture_view:dimension="cube-array";arrayLayerCount=12] + expected: FAIL + + [webgpu:api,validation,createView:creating_texture_view_on_a_2D_array_texture:arrayLayerCount=0;baseArrayLayer=5] + expected: FAIL + + [webgpu:api,validation,createView:creating_texture_view_on_a_2D_array_texture:arrayLayerCount=0;baseArrayLayer=0] + expected: FAIL + + [webgpu:api,validation,createView:creating_texture_view_on_a_2D_array_texture:arrayLayerCount=0;baseArrayLayer=1] + expected: FAIL + + [webgpu:api,validation,createView:creating_texture_view_on_a_2D_non_array_texture:mipLevelCount=0;baseMipLevel=0] + expected: FAIL + + [webgpu:api,validation,createView:creating_texture_view_on_a_2D_non_array_texture:mipLevelCount=0;baseMipLevel=1] + expected: FAIL + + [webgpu:api,validation,createView:Using_defaults_validates_the_same_as_setting_values_for_only_1_array_layer:arrayLayerCount=0] + expected: FAIL + + [webgpu:api,validation,createView:creating_texture_view_on_a_2D_non_array_texture:mipLevelCount=0;baseMipLevel=5] + expected: FAIL + + [webgpu:api,validation,createView:creating_cube_map_texture_view:dimension="cube";arrayLayerCount=6] + expected: FAIL + + +[cts.html?q=webgpu:api,validation,setVertexBuffer:*] + [webgpu:api,validation,setVertexBuffer:vertex_buffers_inherit_from_previous_pipeline:] + expected: FAIL + + [webgpu:api,validation,setVertexBuffer:vertex_buffers_do_not_inherit_between_render_passes:] + expected: FAIL + + +[cts.html?q=webgpu:api,validation,render_pass,storeOp:*] + expected: ERROR + +[cts.html?q=webgpu:api,validation,createPipelineLayout:*] + +[cts.html?q=webgpu:api,operation,command_buffer,render,basic:*] + [webgpu:api,operation,command_buffer,render,basic:clear:] + expected: FAIL + diff --git a/tests/wpt/webgpu/meta/webgpu/webgpu/web-platform/reftests/canvas_clear.html.ini b/tests/wpt/webgpu/meta/webgpu/webgpu/web-platform/reftests/canvas_clear.html.ini new file mode 100644 index 00000000000..86e10a61825 --- /dev/null +++ b/tests/wpt/webgpu/meta/webgpu/webgpu/web-platform/reftests/canvas_clear.html.ini @@ -0,0 +1,2 @@ +[canvas_clear.html] + expected: FAIL diff --git a/tests/wpt/webgpu/meta/webgpu/webgpu/web-platform/reftests/canvas_complex_bgra8unorm.html.ini b/tests/wpt/webgpu/meta/webgpu/webgpu/web-platform/reftests/canvas_complex_bgra8unorm.html.ini new file mode 100644 index 00000000000..2dec29cbaea --- /dev/null +++ b/tests/wpt/webgpu/meta/webgpu/webgpu/web-platform/reftests/canvas_complex_bgra8unorm.html.ini @@ -0,0 +1,2 @@ +[canvas_complex_bgra8unorm.html] + expected: TIMEOUT From 4622c876fa6866dac88a311621f4e6bee182d833 Mon Sep 17 00:00:00 2001 From: Kunal Mohan Date: Fri, 31 Jul 2020 11:58:35 +0530 Subject: [PATCH 4/6] Run webgpu tests only on macOS --- etc/taskcluster/decision_task.py | 22 ++++++++++++++++++++-- tests/wpt/include.ini | 2 -- 2 files changed, 20 insertions(+), 4 deletions(-) diff --git a/etc/taskcluster/decision_task.py b/etc/taskcluster/decision_task.py index 8f2b29eb1a9..c06ebc8e58f 100644 --- a/etc/taskcluster/decision_task.py +++ b/etc/taskcluster/decision_task.py @@ -549,6 +549,7 @@ def macos_wpt(): repo_dir="repo", total_chunks=20, processes=8, + run_webgpu=True, ) @@ -569,7 +570,7 @@ def linux_wpt_common(total_chunks, layout_2020): def wpt_chunks(platform, make_chunk_task, build_task, total_chunks, processes, - repo_dir, chunks="all", layout_2020=False): + repo_dir, chunks="all", layout_2020=False, run_webgpu=False): if layout_2020: start = 1 # Skip the "extra" WPT testing, a.k.a. chunk 0 name_prefix = "Layout 2020 " @@ -618,6 +619,22 @@ def wpt_chunks(platform, make_chunk_task, build_task, total_chunks, processes, # and wptrunner does not use "interactive mode" formatting: # https://github.com/servo/servo/issues/22438 if this_chunk == 0: + if run_webgpu: + webgpu_script = """ + time ./mach test-wpt _webgpu --release --processes $PROCESSES \ + --headless --log-raw test-webgpu.log \ + --log-errorsummary webgpu-errorsummary.log \ + | cat + ./mach filter-intermittents \ + webgpu-errorsummary.log \ + --log-intermittents webgpu-intermittents.log \ + --log-filteredsummary filtered-webgpu-errorsummary.log \ + --tracker-api default \ + --reporter-api default + """ + else: + webgpu_script = "" + task.with_script(""" time python ./mach test-wpt --release --binary-arg=--multiprocess \ --processes $PROCESSES \ @@ -654,7 +671,8 @@ def wpt_chunks(platform, make_chunk_task, build_task, total_chunks, processes, --log-filteredsummary filtered-wdspec-errorsummary.log \ --tracker-api default \ --reporter-api default - """) + """ + webgpu_script + ) else: task.with_script(""" ./mach test-wpt \ diff --git a/tests/wpt/include.ini b/tests/wpt/include.ini index 27efd8798b9..340c10ad166 100644 --- a/tests/wpt/include.ini +++ b/tests/wpt/include.ini @@ -5,8 +5,6 @@ skip: true skip: false [_webgl] skip: false -[_webgpu] - skip: false [cookies] skip: false [samesite] From 89bfe6a7f119c6723861bf92fde155f2c7fd202f Mon Sep 17 00:00:00 2001 From: Kunal Mohan Date: Sun, 2 Aug 2020 17:10:28 +0530 Subject: [PATCH 5/6] Disable unexpectedly crashing tests --- tests/wpt/webgpu/meta/MANIFEST.json | 18 +----------------- tests/wpt/webgpu/meta/webgpu/cts.html.ini | 4 ++++ tests/wpt/webgpu/tests/webgpu/cts.html | 8 ++++---- 3 files changed, 9 insertions(+), 21 deletions(-) diff --git a/tests/wpt/webgpu/meta/MANIFEST.json b/tests/wpt/webgpu/meta/MANIFEST.json index 5fe88f43059..fb91672dcf6 100644 --- a/tests/wpt/webgpu/meta/MANIFEST.json +++ b/tests/wpt/webgpu/meta/MANIFEST.json @@ -489,7 +489,7 @@ "testharness": { "webgpu": { "cts.html": [ - "40941fb9520652e95c3f356b05b73310b3ebdddb", + "0e637156fa95e5039db18c62136f73595b92c087", [ "webgpu/cts.html?q=webgpu:api,operation,buffers,create_mapped:*", {} @@ -558,26 +558,14 @@ "webgpu/cts.html?q=webgpu:api,validation,createBindGroup:*", {} ], - [ - "webgpu/cts.html?q=webgpu:api,validation,createBindGroupLayout:*", - {} - ], [ "webgpu/cts.html?q=webgpu:api,validation,createPipelineLayout:*", {} ], - [ - "webgpu/cts.html?q=webgpu:api,validation,createRenderPipeline:*", - {} - ], [ "webgpu/cts.html?q=webgpu:api,validation,createTexture:*", {} ], - [ - "webgpu/cts.html?q=webgpu:api,validation,createView:*", - {} - ], [ "webgpu/cts.html?q=webgpu:api,validation,encoding,cmds,index_access:*", {} @@ -630,10 +618,6 @@ "webgpu/cts.html?q=webgpu:api,validation,setViewport:*", {} ], - [ - "webgpu/cts.html?q=webgpu:api,validation,vertex_state:*", - {} - ], [ "webgpu/cts.html?q=webgpu:examples:*", {} diff --git a/tests/wpt/webgpu/meta/webgpu/cts.html.ini b/tests/wpt/webgpu/meta/webgpu/cts.html.ini index 0c194e42090..6bf8bb883ae 100644 --- a/tests/wpt/webgpu/meta/webgpu/cts.html.ini +++ b/tests/wpt/webgpu/meta/webgpu/cts.html.ini @@ -4,6 +4,7 @@ [cts.html?q=webgpu:api,validation,createRenderPipeline:*] + expected: ERROR [webgpu:api,validation,createRenderPipeline:sample_count_must_be_valid:sampleCount=2] expected: FAIL @@ -3900,6 +3901,7 @@ [cts.html?q=webgpu:api,validation,createBindGroupLayout:*] + expected: ERROR [webgpu:api,validation,createBindGroupLayout:max_resources_per_stage,in_bind_group_layout:maxedType="sampled-texture";maxedVisibility=2;extraType="sampled-texture";extraVisibility=4] expected: FAIL @@ -6820,6 +6822,7 @@ [cts.html?q=webgpu:api,validation,vertex_state:*] + expected: ERROR [webgpu:api,validation,vertex_state:pipeline_vertex_buffers_are_backed_by_attributes_in_vertex_input:] expected: FAIL @@ -15712,6 +15715,7 @@ [cts.html?q=webgpu:api,validation,createView:*] + expected: ERROR [webgpu:api,validation,createView:Using_defaults_validates_the_same_as_setting_values_for_more_than_1_array_layer:dimension="2d"] expected: FAIL diff --git a/tests/wpt/webgpu/tests/webgpu/cts.html b/tests/wpt/webgpu/tests/webgpu/cts.html index 40941fb9520..0e637156fa9 100644 --- a/tests/wpt/webgpu/tests/webgpu/cts.html +++ b/tests/wpt/webgpu/tests/webgpu/cts.html @@ -44,11 +44,11 @@ - + - + - + @@ -62,7 +62,7 @@ - + From 75fb6ca589cb97eb933208914a6d2e08ff8dd447 Mon Sep 17 00:00:00 2001 From: Kunal Mohan Date: Tue, 4 Aug 2020 21:29:00 +0530 Subject: [PATCH 6/6] Improve intermittent filtering --- python/servo/testing_commands.py | 14 ++++++++++++-- 1 file changed, 12 insertions(+), 2 deletions(-) diff --git a/python/servo/testing_commands.py b/python/servo/testing_commands.py index f5784ce4f4d..5d05eb60300 100644 --- a/python/servo/testing_commands.py +++ b/python/servo/testing_commands.py @@ -552,6 +552,8 @@ class MachCommands(CommandBase): elif tracker_api.endswith('/'): tracker_api = tracker_api[0:-1] + if 'test' not in failure: + continue query = urllib.parse.quote(failure['test'], safe='') request = urllib.request.Request("%s/query.py?name=%s" % (tracker_api, query)) search = urllib.request.urlopen(request) @@ -569,9 +571,17 @@ class MachCommands(CommandBase): is_intermittent = data['total_count'] > 0 if is_intermittent: - intermittents.append(failure["output"]) + if 'output' in failure: + intermittents.append(failure["output"]) + else: + intermittents.append("%s [expected %s] %s \n" + % (failure["status"], failure["expected"], failure['test'])) else: - actual_failures.append(failure["output"]) + if 'output' in failure: + actual_failures.append(failure["output"]) + else: + actual_failures.append("%s [expected %s] %s \n" + % (failure["status"], failure["expected"], failure['test'])) def format(outputs, description, file=sys.stdout): formatted = "%s %s:\n%s" % (len(outputs), description, "\n".join(outputs))

Qt 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