Deferred error reporting for other command encoder operations

* clear commands
* query set functions
* command_encoder_as_hal_mut
* ray_tracing

Author: andyleiserson

tests/src/lib.rs

@@ -27,6 +27,13 @@ pub use run::{execute_test, TestingContext};
 pub use wgpu_macros::gpu_test;
 
 /// Run some code in an error scope and assert that validation fails.
+///
+/// Note that errors related to commands for the GPU (i.e. raised by methods on
+/// GPUCommandEncoder, GPURenderPassEncoder, GPUComputePassEncoder,
+/// GPURenderBundleEncoder) are usually not raised immediately. They are raised
+/// only when `finish()` is called on the command encoder. Tests of such error
+/// cases should call `fail` with a closure that calls `finish()`, not with a
+/// closure that encodes the actual command.
 pub fn fail<T>(
     device: &wgpu::Device,
     callback: impl FnOnce() -> T,

tests/tests/wgpu-gpu/buffer.rs

@@ -344,13 +344,12 @@ static CLEAR_OFFSET_OUTSIDE_RESOURCE_BOUNDS: GpuTestConfiguration = GpuTestConfi
 
         let out_of_bounds = size.checked_add(wgpu::COPY_BUFFER_ALIGNMENT).unwrap();
 
+        let mut encoder = ctx.device.create_command_encoder(&Default::default());
+        encoder.clear_buffer(&buffer, out_of_bounds, None);
+
         wgpu_test::fail(
             &ctx.device,
-            || {
-                ctx.device
-                    .create_command_encoder(&Default::default())
-                    .clear_buffer(&buffer, out_of_bounds, None)
-            },
+            || encoder.finish(),
             Some("Clear of 20..20 would end up overrunning the bounds of the buffer of size 16"),
         );
     });
@@ -370,17 +369,16 @@ static CLEAR_OFFSET_PLUS_SIZE_OUTSIDE_U64_BOUNDS: GpuTestConfiguration =
             let max_valid_offset = u64::MAX - (u64::MAX % wgpu::COPY_BUFFER_ALIGNMENT);
             let smallest_aligned_invalid_size = wgpu::COPY_BUFFER_ALIGNMENT;
 
+            let mut encoder = ctx.device.create_command_encoder(&Default::default());
+            encoder.clear_buffer(
+                &buffer,
+                max_valid_offset,
+                Some(smallest_aligned_invalid_size),
+            );
+
             wgpu_test::fail(
                 &ctx.device,
-                || {
-                    ctx.device
-                        .create_command_encoder(&Default::default())
-                        .clear_buffer(
-                            &buffer,
-                            max_valid_offset,
-                            Some(smallest_aligned_invalid_size),
-                        )
-                },
+                || encoder.finish(),
                 Some(concat!(
                     "Clear starts at offset 18446744073709551612 with size of 4, ",
                     "but these added together exceed `u64::MAX`"

tests/tests/wgpu-gpu/device.rs

@@ -330,20 +330,19 @@ static DEVICE_DESTROY_THEN_MORE: GpuTestConfiguration = GpuTestConfiguration::ne
         );
 
         // Texture clear should fail.
+        encoder_for_clear.clear_texture(
+            &texture_for_write,
+            &wgpu::ImageSubresourceRange {
+                aspect: wgpu::TextureAspect::All,
+                base_mip_level: 0,
+                mip_level_count: None,
+                base_array_layer: 0,
+                array_layer_count: None,
+            },
+        );
         fail(
             &ctx.device,
-            || {
-                encoder_for_clear.clear_texture(
-                    &texture_for_write,
-                    &wgpu::ImageSubresourceRange {
-                        aspect: wgpu::TextureAspect::All,
-                        base_mip_level: 0,
-                        mip_level_count: None,
-                        base_array_layer: 0,
-                        array_layer_count: None,
-                    },
-                );
-            },
+            || encoder_for_clear.finish(),
             Some("device with '' label is invalid"),
         );
 

tests/tests/wgpu-gpu/ray_tracing/as_build.rs

@@ -188,11 +188,8 @@ fn blas_compaction(ctx: TestingContext) {
     let mut build_entry = as_ctx.blas_build_entry();
     build_entry.blas = &compacted;
 
-    fail(
-        &ctx.device,
-        || fail_encoder.build_acceleration_structures([&build_entry], []),
-        None,
-    );
+    fail_encoder.build_acceleration_structures([&build_entry], []);
+    fail(&ctx.device, || fail_encoder.finish(), None);
 }
 
 #[gpu_test]
@@ -733,13 +730,8 @@ fn only_tlas_vertex_return(ctx: TestingContext) {
             label: Some("TLAS 1"),
         });
 
-    fail(
-        &ctx.device,
-        || {
-            encoder_tlas.build_acceleration_structures([], [&as_ctx.tlas]);
-        },
-        None,
-    );
+    encoder_tlas.build_acceleration_structures([], [&as_ctx.tlas]);
+    fail(&ctx.device, || encoder_tlas.finish(), None);
 }
 
 #[gpu_test]
@@ -817,30 +809,29 @@ fn test_as_build_format_stride(
         .create_command_encoder(&CommandEncoderDescriptor {
             label: Some("BLAS_1"),
         });
-    fail_if(
+    command_encoder.build_acceleration_structures(
+        &[BlasBuildEntry {
+            blas: &blas,
+            geometry: BlasGeometries::TriangleGeometries(vec![BlasTriangleGeometry {
+                size: &blas_size,
+                vertex_buffer: &vertices,
+                first_vertex: 0,
+                vertex_stride: stride,
+                index_buffer: None,
+                first_index: None,
+                transform_buffer: None,
+                transform_buffer_offset: None,
+            }]),
+        }],
+        &[],
+    );
+    let command_buffer = fail_if(
         &ctx.device,
         invalid_combination,
-        || {
-            command_encoder.build_acceleration_structures(
-                &[BlasBuildEntry {
-                    blas: &blas,
-                    geometry: BlasGeometries::TriangleGeometries(vec![BlasTriangleGeometry {
-                        size: &blas_size,
-                        vertex_buffer: &vertices,
-                        first_vertex: 0,
-                        vertex_stride: stride,
-                        index_buffer: None,
-                        first_index: None,
-                        transform_buffer: None,
-                        transform_buffer_offset: None,
-                    }]),
-                }],
-                &[],
-            )
-        },
+        || command_encoder.finish(),
         None,
     );
     if !invalid_combination {
-        ctx.queue.submit([command_encoder.finish()]);
+        ctx.queue.submit([command_buffer]);
     }
 }