chromium/src/third_party/blink/web_tests/wpt_internal/webgpu/webgpu/shader/execution/robust_access_vertex.spec.js - manifest_repos/chromium_src - Git at Google

 /**
  * AUTO-GENERATED - DO NOT EDIT. Source: https://github.com/gpuweb/cts
  **/ 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) {
     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, 'uint16');
     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, 'uint16');
     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 = this.device.createBuffer({
       size,
       usage: GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST,
     });

     if (partialLastNumber) {
       size -= 3;
     }
     this.device.defaultQueue.writeBuffer(vertexBuffer, 0, vertexArray, size);
     return vertexBuffer;
   }

   // Create an index buffer from |indexArray|
   generateIndexBuffer(indexArray) {
     const indexBuffer = this.device.createBuffer({
       size: indexArray.byteLength,
       usage: GPUBufferUsage.INDEX | GPUBufferUsage.COPY_DST,
     });

     this.device.defaultQueue.writeBuffer(indexBuffer, 0, indexArray);
     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 = this.device.createBuffer({
       mappedAtCreation: true,
       size: indirectArray.byteLength,
       usage: GPUBufferUsage.INDIRECT,
     });

     new Int32Array(indirectBuffer.getMappedRange()).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 = this.device.createBuffer({
       mappedAtCreation: true,
       size: indirectArray.byteLength,
       usage: GPUBufferUsage.INDIRECT,
     });

     new Int32Array(indirectBuffer.getMappedRange()).set(indirectArray);
     indirectBuffer.unmap();
     return indirectBuffer;
   }
 }

 // Parameterize different sized types

 const typeInfoMap = {
   float: {
     wgslType: 'f32',
     size: 4,
     validationFunc: 'return valid(v);',
   },

   float2: {
     wgslType: 'vec2<f32>',
     size: 8,
     validationFunc: 'return valid(v.x) && valid(v.y);',
   },

   float3: {
     wgslType: 'vec3<f32>',
     size: 12,
     validationFunc: 'return valid(v.x) && valid(v.y) && valid(v.z);',
   },

   float4: {
     wgslType: 'vec4<f32>',
     size: 16,
     validationFunc: `return valid(v.x) && valid(v.y) && valid(v.z) && valid(v.w) ||
                             v.x == 0.0 && v.y == 0.0 && v.z == 0.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, odd so that uint16 index buffers are aligned to size 4
     const numVertices = 4;
     // 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 += `[[location(${currAttribute})]] var<in> a_${currAttribute} : ${typeInfo.wgslType};\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: p.type,
             })),
         });
       }
     }

     // Offset the range checks for gl_VertexIndex in the shader if we use BaseVertex
     let vertexIndexOffset = 0;
     if (p.drawCallTestParameter === 'baseVertex') {
       vertexIndexOffset += p.errorScale;
     }

     const pipeline = t.device.createRenderPipeline({
       vertexStage: {
         module: t.device.createShaderModule({
           code: `
             [[builtin(position)]] var<out> Position : vec4<f32>;
             [[builtin(vertex_idx)]] var<in> VertexIndex : u32;
             ${layoutStr}

             fn valid(f : f32) -> bool {
               return ${validValues.map(v => `f == ${v}.0`).join(' || ')};
             }

             fn validationFunc(v : ${typeInfo.wgslType}) -> bool {
               ${typeInfo.validationFunc}
             }

             [[stage(vertex)]] fn main() -> void {
               var attributesInBounds : bool = ${attributeNames
                 .map(a => `validationFunc(${a})`)
                 .join(' && ')};
               var indexInBounds : bool = VertexIndex == 0u ||
                   (VertexIndex >= ${vertexIndexOffset}u &&
                    VertexIndex < ${vertexIndexOffset + numVertices}u);

               if (attributesInBounds && (${!p.indexed} || indexInBounds)) {
                 // Success case, move the vertex out of the viewport
                 Position = vec4<f32>(-1.0, 0.0, 0.0, 1.0);
               } else {
                 // Failure case, move the vertex inside the viewport
                 Position = vec4<f32>(0.0, 0.0, 0.0, 1.0);
               }
             }`,
         }),

         entryPoint: 'main',
       },

       fragmentStage: {
         module: t.device.createShaderModule({
           code: `
             [[location(0)]] var<out> fragColor : vec4<f32>;
             [[stage(fragment)]] fn main() -> void {
               fragColor = vec4<f32>(1.0, 0.0, 0.0, 1.0);
             }`,
         }),

         entryPoint: 'main',
       },

       primitiveTopology: 'point-list',
       colorStates: [{ format: 'rgba8unorm' }],
       vertexState: {
         vertexBuffers,
       },
     });

     // 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();

     // 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 } }
     );
   });
	/**
	* AUTO-GENERATED - DO NOT EDIT. Source: https://github.com/gpuweb/cts
	**/ 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) {
	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, 'uint16');
	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, 'uint16');
	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 = this.device.createBuffer({
	size,
	usage: GPUBufferUsage.VERTEX \| GPUBufferUsage.COPY_DST,
	});

	if (partialLastNumber) {
	size -= 3;
	}
	this.device.defaultQueue.writeBuffer(vertexBuffer, 0, vertexArray, size);
	return vertexBuffer;
	}

	// Create an index buffer from \|indexArray\|
	generateIndexBuffer(indexArray) {
	const indexBuffer = this.device.createBuffer({
	size: indexArray.byteLength,
	usage: GPUBufferUsage.INDEX \| GPUBufferUsage.COPY_DST,
	});

	this.device.defaultQueue.writeBuffer(indexBuffer, 0, indexArray);
	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 = this.device.createBuffer({
	mappedAtCreation: true,
	size: indirectArray.byteLength,
	usage: GPUBufferUsage.INDIRECT,
	});

	new Int32Array(indirectBuffer.getMappedRange()).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 = this.device.createBuffer({
	mappedAtCreation: true,
	size: indirectArray.byteLength,
	usage: GPUBufferUsage.INDIRECT,
	});

	new Int32Array(indirectBuffer.getMappedRange()).set(indirectArray);
	indirectBuffer.unmap();
	return indirectBuffer;
	}
	}

	// Parameterize different sized types

	const typeInfoMap = {
	float: {
	wgslType: 'f32',
	size: 4,
	validationFunc: 'return valid(v);',
	},

	float2: {
	wgslType: 'vec2<f32>',
	size: 8,
	validationFunc: 'return valid(v.x) && valid(v.y);',
	},

	float3: {
	wgslType: 'vec3<f32>',
	size: 12,
	validationFunc: 'return valid(v.x) && valid(v.y) && valid(v.z);',
	},

	float4: {
	wgslType: 'vec4<f32>',
	size: 16,
	validationFunc: `return valid(v.x) && valid(v.y) && valid(v.z) && valid(v.w) \|\|
	v.x == 0.0 && v.y == 0.0 && v.z == 0.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, odd so that uint16 index buffers are aligned to size 4
	const numVertices = 4;
	// 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 += `[[location(${currAttribute})]] var<in> a_${currAttribute} : ${typeInfo.wgslType};\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: p.type,
	})),
	});
	}
	}

	// Offset the range checks for gl_VertexIndex in the shader if we use BaseVertex
	let vertexIndexOffset = 0;
	if (p.drawCallTestParameter === 'baseVertex') {
	vertexIndexOffset += p.errorScale;
	}

	const pipeline = t.device.createRenderPipeline({
	vertexStage: {
	module: t.device.createShaderModule({
	code: `
	[[builtin(position)]] var<out> Position : vec4<f32>;
	[[builtin(vertex_idx)]] var<in> VertexIndex : u32;
	${layoutStr}

	fn valid(f : f32) -> bool {
	return ${validValues.map(v => `f == ${v}.0`).join(' \|\| ')};
	}

	fn validationFunc(v : ${typeInfo.wgslType}) -> bool {
	${typeInfo.validationFunc}
	}

	[[stage(vertex)]] fn main() -> void {
	var attributesInBounds : bool = ${attributeNames
	.map(a => `validationFunc(${a})`)
	.join(' && ')};
	var indexInBounds : bool = VertexIndex == 0u \|\|
	(VertexIndex >= ${vertexIndexOffset}u &&
	VertexIndex < ${vertexIndexOffset + numVertices}u);

	if (attributesInBounds && (${!p.indexed} \|\| indexInBounds)) {
	// Success case, move the vertex out of the viewport
	Position = vec4<f32>(-1.0, 0.0, 0.0, 1.0);
	} else {
	// Failure case, move the vertex inside the viewport
	Position = vec4<f32>(0.0, 0.0, 0.0, 1.0);
	}
	}`,
	}),

	entryPoint: 'main',
	},

	fragmentStage: {
	module: t.device.createShaderModule({
	code: `
	[[location(0)]] var<out> fragColor : vec4<f32>;
	[[stage(fragment)]] fn main() -> void {
	fragColor = vec4<f32>(1.0, 0.0, 0.0, 1.0);
	}`,
	}),

	entryPoint: 'main',
	},

	primitiveTopology: 'point-list',
	colorStates: [{ format: 'rgba8unorm' }],
	vertexState: {
	vertexBuffers,
	},
	});

	// 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();

	// 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 } }
	);
	});