vkrust 0.13.2+1.4.365

// @generated by vk-gen — API signatures and missing-command contracts.
// These share registry metadata with the emitter; independent ABI/behavior proofs remain separate.
use super::command::Fixture;
use ::vk::{self, CallError};

#[test]
fn get_physical_device_format_properties_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		vk::PhysicalDevice,
		vk::Format,
		&mut vk::FormatProperties,
	) -> Result<(), CallError>;
	let _: Signature = vk::get_physical_device_format_properties;
	let _: Signature = vk::Instance::get_physical_device_format_properties;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_physical_device_format_properties(
				&fixture.instance,
				Default::default(),
				Default::default(),
				&mut std::mem::zeroed::<vk::FormatProperties>()
			),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceFormatProperties"
			))
		));
		assert!(matches!(
			fixture.instance.get_physical_device_format_properties(
				Default::default(),
				Default::default(),
				&mut std::mem::zeroed::<vk::FormatProperties>()
			),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceFormatProperties"
			))
		));
	}
}

#[test]
fn get_physical_device_image_format_properties_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		vk::PhysicalDevice,
		vk::Format,
		vk::ImageType,
		vk::ImageTiling,
		vk::ImageUsageFlags,
		vk::ImageCreateFlags,
		&mut vk::ImageFormatProperties,
	) -> Result<(), CallError>;
	let _: Signature = vk::get_physical_device_image_format_properties;
	let _: Signature = vk::Instance::get_physical_device_image_format_properties;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_physical_device_image_format_properties(
				&fixture.instance,
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default(),
				&mut std::mem::zeroed::<vk::ImageFormatProperties>()
			),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceImageFormatProperties"
			))
		));
		assert!(matches!(
			fixture
				.instance
				.get_physical_device_image_format_properties(
					Default::default(),
					Default::default(),
					Default::default(),
					Default::default(),
					Default::default(),
					Default::default(),
					&mut std::mem::zeroed::<vk::ImageFormatProperties>()
				),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceImageFormatProperties"
			))
		));
	}
}

#[test]
fn enumerate_device_layer_properties_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Instance, vk::PhysicalDevice) -> Result<Vec<vk::LayerProperties>, CallError>;
	let _: Signature = vk::enumerate_device_layer_properties;
	let _: Signature = vk::Instance::enumerate_device_layer_properties;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::enumerate_device_layer_properties(&fixture.instance, Default::default()),
			Err(CallError::MissingCommand(
				"vkEnumerateDeviceLayerProperties"
			))
		));
		assert!(matches!(
			fixture
				.instance
				.enumerate_device_layer_properties(Default::default()),
			Err(CallError::MissingCommand(
				"vkEnumerateDeviceLayerProperties"
			))
		));
	}
}

#[test]
fn device_wait_idle_signature_and_missing_command() {
	type Signature = unsafe fn(&vk::Device) -> Result<(), CallError>;
	let _: Signature = vk::device_wait_idle;
	let _: Signature = vk::Device::device_wait_idle;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::device_wait_idle(&fixture.device,),
			Err(CallError::MissingCommand("vkDeviceWaitIdle"))
		));
		assert!(matches!(
			fixture.device.device_wait_idle(),
			Err(CallError::MissingCommand("vkDeviceWaitIdle"))
		));
	}
}

#[test]
fn get_device_memory_commitment_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, vk::DeviceMemory, &mut vk::DeviceSize) -> Result<(), CallError>;
	let _: Signature = vk::get_device_memory_commitment;
	let _: Signature = vk::Device::get_device_memory_commitment;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_device_memory_commitment(
				&fixture.device,
				Default::default(),
				&mut std::mem::zeroed::<vk::DeviceSize>()
			),
			Err(CallError::MissingCommand("vkGetDeviceMemoryCommitment"))
		));
		assert!(matches!(
			fixture.device.get_device_memory_commitment(
				Default::default(),
				&mut std::mem::zeroed::<vk::DeviceSize>()
			),
			Err(CallError::MissingCommand("vkGetDeviceMemoryCommitment"))
		));
	}
}

#[test]
fn get_image_memory_requirements_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, vk::Image, &mut vk::MemoryRequirements) -> Result<(), CallError>;
	let _: Signature = vk::get_image_memory_requirements;
	let _: Signature = vk::Device::get_image_memory_requirements;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_image_memory_requirements(
				&fixture.device,
				Default::default(),
				&mut std::mem::zeroed::<vk::MemoryRequirements>()
			),
			Err(CallError::MissingCommand("vkGetImageMemoryRequirements"))
		));
		assert!(matches!(
			fixture.device.get_image_memory_requirements(
				Default::default(),
				&mut std::mem::zeroed::<vk::MemoryRequirements>()
			),
			Err(CallError::MissingCommand("vkGetImageMemoryRequirements"))
		));
	}
}

#[test]
fn bind_image_memory_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, vk::Image, vk::DeviceMemory, vk::DeviceSize) -> Result<(), CallError>;
	let _: Signature = vk::bind_image_memory;
	let _: Signature = vk::Device::bind_image_memory;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::bind_image_memory(
				&fixture.device,
				Default::default(),
				Default::default(),
				Default::default()
			),
			Err(CallError::MissingCommand("vkBindImageMemory"))
		));
		assert!(matches!(
			fixture
				.device
				.bind_image_memory(Default::default(), Default::default(), Default::default()),
			Err(CallError::MissingCommand("vkBindImageMemory"))
		));
	}
}

#[test]
fn get_image_sparse_memory_requirements_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, vk::Image) -> Result<Vec<vk::SparseImageMemoryRequirements>, CallError>;
	let _: Signature = vk::get_image_sparse_memory_requirements;
	let _: Signature = vk::Device::get_image_sparse_memory_requirements;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_image_sparse_memory_requirements(&fixture.device, Default::default()),
			Err(CallError::MissingCommand(
				"vkGetImageSparseMemoryRequirements"
			))
		));
		assert!(matches!(
			fixture
				.device
				.get_image_sparse_memory_requirements(Default::default()),
			Err(CallError::MissingCommand(
				"vkGetImageSparseMemoryRequirements"
			))
		));
	}
}

#[test]
fn get_physical_device_sparse_image_format_properties_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		vk::PhysicalDevice,
		vk::Format,
		vk::ImageType,
		vk::SampleCountFlagBits,
		vk::ImageUsageFlags,
		vk::ImageTiling,
	) -> Result<Vec<vk::SparseImageFormatProperties>, CallError>;
	let _: Signature = vk::get_physical_device_sparse_image_format_properties;
	let _: Signature = vk::Instance::get_physical_device_sparse_image_format_properties;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_physical_device_sparse_image_format_properties(
				&fixture.instance,
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default()
			),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceSparseImageFormatProperties"
			))
		));
		assert!(matches!(
			fixture
				.instance
				.get_physical_device_sparse_image_format_properties(
					Default::default(),
					Default::default(),
					Default::default(),
					Default::default(),
					Default::default(),
					Default::default()
				),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceSparseImageFormatProperties"
			))
		));
	}
}

#[test]
fn queue_bind_sparse_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::Queue,
		&[vk::BindSparseInfo<'_>],
		vk::Fence,
	) -> Result<(), CallError>;
	let _: Signature = vk::queue_bind_sparse;
	let _: Signature = vk::Device::queue_bind_sparse;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::queue_bind_sparse(&fixture.device, Default::default(), &[], Default::default()),
			Err(CallError::MissingCommand("vkQueueBindSparse"))
		));
		assert!(matches!(
			fixture
				.device
				.queue_bind_sparse(Default::default(), &[], Default::default()),
			Err(CallError::MissingCommand("vkQueueBindSparse"))
		));
	}
}

#[test]
fn get_fence_status_signature_and_missing_command() {
	type Signature = unsafe fn(&vk::Device, vk::Fence) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_fence_status;
	let _: Signature = vk::Device::get_fence_status;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_fence_status(&fixture.device, Default::default()),
			Err(CallError::MissingCommand("vkGetFenceStatus"))
		));
		assert!(matches!(
			fixture.device.get_fence_status(Default::default()),
			Err(CallError::MissingCommand("vkGetFenceStatus"))
		));
	}
}

#[test]
fn create_semaphore_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		&vk::SemaphoreCreateInfo<'_>,
		Option<&vk::AllocationCallbacks>,
	) -> Result<vk::Semaphore, CallError>;
	let _: Signature = vk::create_semaphore;
	let _: Signature = vk::Device::create_semaphore;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::create_semaphore(
				&fixture.device,
				&std::mem::zeroed::<vk::SemaphoreCreateInfo<'_>>(),
				None
			),
			Err(CallError::MissingCommand("vkCreateSemaphore"))
		));
		assert!(matches!(
			fixture
				.device
				.create_semaphore(&std::mem::zeroed::<vk::SemaphoreCreateInfo<'_>>(), None),
			Err(CallError::MissingCommand("vkCreateSemaphore"))
		));
	}
}

#[test]
fn destroy_semaphore_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::Semaphore,
		Option<&vk::AllocationCallbacks>,
	) -> Result<(), CallError>;
	let _: Signature = vk::destroy_semaphore;
	let _: Signature = vk::Device::destroy_semaphore;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::destroy_semaphore(&fixture.device, Default::default(), None),
			Err(CallError::MissingCommand("vkDestroySemaphore"))
		));
		assert!(matches!(
			fixture.device.destroy_semaphore(Default::default(), None),
			Err(CallError::MissingCommand("vkDestroySemaphore"))
		));
	}
}

#[test]
fn create_event_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		&vk::EventCreateInfo<'_>,
		Option<&vk::AllocationCallbacks>,
	) -> Result<vk::Event, CallError>;
	let _: Signature = vk::create_event;
	let _: Signature = vk::Device::create_event;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::create_event(
				&fixture.device,
				&std::mem::zeroed::<vk::EventCreateInfo<'_>>(),
				None
			),
			Err(CallError::MissingCommand("vkCreateEvent"))
		));
		assert!(matches!(
			fixture
				.device
				.create_event(&std::mem::zeroed::<vk::EventCreateInfo<'_>>(), None),
			Err(CallError::MissingCommand("vkCreateEvent"))
		));
	}
}

#[test]
fn destroy_event_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, vk::Event, Option<&vk::AllocationCallbacks>) -> Result<(), CallError>;
	let _: Signature = vk::destroy_event;
	let _: Signature = vk::Device::destroy_event;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::destroy_event(&fixture.device, Default::default(), None),
			Err(CallError::MissingCommand("vkDestroyEvent"))
		));
		assert!(matches!(
			fixture.device.destroy_event(Default::default(), None),
			Err(CallError::MissingCommand("vkDestroyEvent"))
		));
	}
}

#[test]
fn get_event_status_signature_and_missing_command() {
	type Signature = unsafe fn(&vk::Device, vk::Event) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_event_status;
	let _: Signature = vk::Device::get_event_status;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_event_status(&fixture.device, Default::default()),
			Err(CallError::MissingCommand("vkGetEventStatus"))
		));
		assert!(matches!(
			fixture.device.get_event_status(Default::default()),
			Err(CallError::MissingCommand("vkGetEventStatus"))
		));
	}
}

#[test]
fn set_event_signature_and_missing_command() {
	type Signature = unsafe fn(&vk::Device, vk::Event) -> Result<(), CallError>;
	let _: Signature = vk::set_event;
	let _: Signature = vk::Device::set_event;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::set_event(&fixture.device, Default::default()),
			Err(CallError::MissingCommand("vkSetEvent"))
		));
		assert!(matches!(
			fixture.device.set_event(Default::default()),
			Err(CallError::MissingCommand("vkSetEvent"))
		));
	}
}

#[test]
fn reset_event_signature_and_missing_command() {
	type Signature = unsafe fn(&vk::Device, vk::Event) -> Result<(), CallError>;
	let _: Signature = vk::reset_event;
	let _: Signature = vk::Device::reset_event;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::reset_event(&fixture.device, Default::default()),
			Err(CallError::MissingCommand("vkResetEvent"))
		));
		assert!(matches!(
			fixture.device.reset_event(Default::default()),
			Err(CallError::MissingCommand("vkResetEvent"))
		));
	}
}

#[test]
fn create_query_pool_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		&vk::QueryPoolCreateInfo<'_>,
		Option<&vk::AllocationCallbacks>,
	) -> Result<vk::QueryPool, CallError>;
	let _: Signature = vk::create_query_pool;
	let _: Signature = vk::Device::create_query_pool;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::create_query_pool(
				&fixture.device,
				&std::mem::zeroed::<vk::QueryPoolCreateInfo<'_>>(),
				None
			),
			Err(CallError::MissingCommand("vkCreateQueryPool"))
		));
		assert!(matches!(
			fixture
				.device
				.create_query_pool(&std::mem::zeroed::<vk::QueryPoolCreateInfo<'_>>(), None),
			Err(CallError::MissingCommand("vkCreateQueryPool"))
		));
	}
}

#[test]
fn destroy_query_pool_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::QueryPool,
		Option<&vk::AllocationCallbacks>,
	) -> Result<(), CallError>;
	let _: Signature = vk::destroy_query_pool;
	let _: Signature = vk::Device::destroy_query_pool;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::destroy_query_pool(&fixture.device, Default::default(), None),
			Err(CallError::MissingCommand("vkDestroyQueryPool"))
		));
		assert!(matches!(
			fixture.device.destroy_query_pool(Default::default(), None),
			Err(CallError::MissingCommand("vkDestroyQueryPool"))
		));
	}
}

#[test]
fn get_query_pool_results_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::QueryPool,
		u32,
		u32,
		&mut [u8],
		vk::DeviceSize,
		vk::QueryResultFlags,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_query_pool_results;
	let _: Signature = vk::Device::get_query_pool_results;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_query_pool_results(
				&fixture.device,
				Default::default(),
				Default::default(),
				Default::default(),
				&mut [],
				Default::default(),
				Default::default()
			),
			Err(CallError::MissingCommand("vkGetQueryPoolResults"))
		));
		assert!(matches!(
			fixture.device.get_query_pool_results(
				Default::default(),
				Default::default(),
				Default::default(),
				&mut [],
				Default::default(),
				Default::default()
			),
			Err(CallError::MissingCommand("vkGetQueryPoolResults"))
		));
	}
}

#[test]
fn reset_query_pool_signature_and_missing_command() {
	type Signature = unsafe fn(&vk::Device, vk::QueryPool, u32, u32) -> Result<(), CallError>;
	let _: Signature = vk::reset_query_pool;
	let _: Signature = vk::Device::reset_query_pool;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::reset_query_pool(
				&fixture.device,
				Default::default(),
				Default::default(),
				Default::default()
			),
			Err(CallError::MissingCommand("vkResetQueryPool"))
		));
		assert!(matches!(
			fixture
				.device
				.reset_query_pool(Default::default(), Default::default(), Default::default()),
			Err(CallError::MissingCommand("vkResetQueryPool"))
		));
	}
}

#[test]
fn reset_query_pool_ext_signature_and_missing_command() {
	type Signature = unsafe fn(&vk::Device, vk::QueryPool, u32, u32) -> Result<(), CallError>;
	let _: Signature = vk::reset_query_pool_ext;
	let _: Signature = vk::Device::reset_query_pool_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::reset_query_pool_ext(
				&fixture.device,
				Default::default(),
				Default::default(),
				Default::default()
			),
			Err(CallError::MissingCommand("vkResetQueryPoolEXT"))
		));
		assert!(matches!(
			fixture.device.reset_query_pool_ext(
				Default::default(),
				Default::default(),
				Default::default()
			),
			Err(CallError::MissingCommand("vkResetQueryPoolEXT"))
		));
	}
}

#[test]
fn create_buffer_view_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		&vk::BufferViewCreateInfo<'_>,
		Option<&vk::AllocationCallbacks>,
	) -> Result<vk::BufferView, CallError>;
	let _: Signature = vk::create_buffer_view;
	let _: Signature = vk::Device::create_buffer_view;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::create_buffer_view(
				&fixture.device,
				&std::mem::zeroed::<vk::BufferViewCreateInfo<'_>>(),
				None
			),
			Err(CallError::MissingCommand("vkCreateBufferView"))
		));
		assert!(matches!(
			fixture
				.device
				.create_buffer_view(&std::mem::zeroed::<vk::BufferViewCreateInfo<'_>>(), None),
			Err(CallError::MissingCommand("vkCreateBufferView"))
		));
	}
}

#[test]
fn destroy_buffer_view_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::BufferView,
		Option<&vk::AllocationCallbacks>,
	) -> Result<(), CallError>;
	let _: Signature = vk::destroy_buffer_view;
	let _: Signature = vk::Device::destroy_buffer_view;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::destroy_buffer_view(&fixture.device, Default::default(), None),
			Err(CallError::MissingCommand("vkDestroyBufferView"))
		));
		assert!(matches!(
			fixture.device.destroy_buffer_view(Default::default(), None),
			Err(CallError::MissingCommand("vkDestroyBufferView"))
		));
	}
}

#[test]
fn create_image_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		&vk::ImageCreateInfo<'_>,
		Option<&vk::AllocationCallbacks>,
	) -> Result<vk::Image, CallError>;
	let _: Signature = vk::create_image;
	let _: Signature = vk::Device::create_image;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::create_image(
				&fixture.device,
				&std::mem::zeroed::<vk::ImageCreateInfo<'_>>(),
				None
			),
			Err(CallError::MissingCommand("vkCreateImage"))
		));
		assert!(matches!(
			fixture
				.device
				.create_image(&std::mem::zeroed::<vk::ImageCreateInfo<'_>>(), None),
			Err(CallError::MissingCommand("vkCreateImage"))
		));
	}
}

#[test]
fn destroy_image_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, vk::Image, Option<&vk::AllocationCallbacks>) -> Result<(), CallError>;
	let _: Signature = vk::destroy_image;
	let _: Signature = vk::Device::destroy_image;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::destroy_image(&fixture.device, Default::default(), None),
			Err(CallError::MissingCommand("vkDestroyImage"))
		));
		assert!(matches!(
			fixture.device.destroy_image(Default::default(), None),
			Err(CallError::MissingCommand("vkDestroyImage"))
		));
	}
}

#[test]
fn get_image_subresource_layout_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::Image,
		&vk::ImageSubresource,
		&mut vk::SubresourceLayout,
	) -> Result<(), CallError>;
	let _: Signature = vk::get_image_subresource_layout;
	let _: Signature = vk::Device::get_image_subresource_layout;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_image_subresource_layout(
				&fixture.device,
				Default::default(),
				&std::mem::zeroed::<vk::ImageSubresource>(),
				&mut std::mem::zeroed::<vk::SubresourceLayout>()
			),
			Err(CallError::MissingCommand("vkGetImageSubresourceLayout"))
		));
		assert!(matches!(
			fixture.device.get_image_subresource_layout(
				Default::default(),
				&std::mem::zeroed::<vk::ImageSubresource>(),
				&mut std::mem::zeroed::<vk::SubresourceLayout>()
			),
			Err(CallError::MissingCommand("vkGetImageSubresourceLayout"))
		));
	}
}

#[test]
fn create_image_view_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		&vk::ImageViewCreateInfo<'_>,
		Option<&vk::AllocationCallbacks>,
	) -> Result<vk::ImageView, CallError>;
	let _: Signature = vk::create_image_view;
	let _: Signature = vk::Device::create_image_view;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::create_image_view(
				&fixture.device,
				&std::mem::zeroed::<vk::ImageViewCreateInfo<'_>>(),
				None
			),
			Err(CallError::MissingCommand("vkCreateImageView"))
		));
		assert!(matches!(
			fixture
				.device
				.create_image_view(&std::mem::zeroed::<vk::ImageViewCreateInfo<'_>>(), None),
			Err(CallError::MissingCommand("vkCreateImageView"))
		));
	}
}

#[test]
fn destroy_image_view_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::ImageView,
		Option<&vk::AllocationCallbacks>,
	) -> Result<(), CallError>;
	let _: Signature = vk::destroy_image_view;
	let _: Signature = vk::Device::destroy_image_view;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::destroy_image_view(&fixture.device, Default::default(), None),
			Err(CallError::MissingCommand("vkDestroyImageView"))
		));
		assert!(matches!(
			fixture.device.destroy_image_view(Default::default(), None),
			Err(CallError::MissingCommand("vkDestroyImageView"))
		));
	}
}

#[test]
fn create_shader_module_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		&vk::ShaderModuleCreateInfo<'_>,
		Option<&vk::AllocationCallbacks>,
	) -> Result<vk::ShaderModule, CallError>;
	let _: Signature = vk::create_shader_module;
	let _: Signature = vk::Device::create_shader_module;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::create_shader_module(
				&fixture.device,
				&std::mem::zeroed::<vk::ShaderModuleCreateInfo<'_>>(),
				None
			),
			Err(CallError::MissingCommand("vkCreateShaderModule"))
		));
		assert!(matches!(
			fixture
				.device
				.create_shader_module(&std::mem::zeroed::<vk::ShaderModuleCreateInfo<'_>>(), None),
			Err(CallError::MissingCommand("vkCreateShaderModule"))
		));
	}
}

#[test]
fn destroy_shader_module_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::ShaderModule,
		Option<&vk::AllocationCallbacks>,
	) -> Result<(), CallError>;
	let _: Signature = vk::destroy_shader_module;
	let _: Signature = vk::Device::destroy_shader_module;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::destroy_shader_module(&fixture.device, Default::default(), None),
			Err(CallError::MissingCommand("vkDestroyShaderModule"))
		));
		assert!(matches!(
			fixture
				.device
				.destroy_shader_module(Default::default(), None),
			Err(CallError::MissingCommand("vkDestroyShaderModule"))
		));
	}
}

#[test]
fn create_pipeline_cache_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		&vk::PipelineCacheCreateInfo<'_>,
		Option<&vk::AllocationCallbacks>,
	) -> Result<vk::PipelineCache, CallError>;
	let _: Signature = vk::create_pipeline_cache;
	let _: Signature = vk::Device::create_pipeline_cache;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::create_pipeline_cache(
				&fixture.device,
				&std::mem::zeroed::<vk::PipelineCacheCreateInfo<'_>>(),
				None
			),
			Err(CallError::MissingCommand("vkCreatePipelineCache"))
		));
		assert!(matches!(
			fixture
				.device
				.create_pipeline_cache(&std::mem::zeroed::<vk::PipelineCacheCreateInfo<'_>>(), None),
			Err(CallError::MissingCommand("vkCreatePipelineCache"))
		));
	}
}

#[test]
fn destroy_pipeline_cache_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::PipelineCache,
		Option<&vk::AllocationCallbacks>,
	) -> Result<(), CallError>;
	let _: Signature = vk::destroy_pipeline_cache;
	let _: Signature = vk::Device::destroy_pipeline_cache;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::destroy_pipeline_cache(&fixture.device, Default::default(), None),
			Err(CallError::MissingCommand("vkDestroyPipelineCache"))
		));
		assert!(matches!(
			fixture
				.device
				.destroy_pipeline_cache(Default::default(), None),
			Err(CallError::MissingCommand("vkDestroyPipelineCache"))
		));
	}
}

#[test]
fn get_pipeline_cache_data_signature_and_missing_command() {
	type Signature = unsafe fn(&vk::Device, vk::PipelineCache) -> Result<Vec<u8>, CallError>;
	let _: Signature = vk::get_pipeline_cache_data;
	let _: Signature = vk::Device::get_pipeline_cache_data;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_pipeline_cache_data(&fixture.device, Default::default()),
			Err(CallError::MissingCommand("vkGetPipelineCacheData"))
		));
		assert!(matches!(
			fixture.device.get_pipeline_cache_data(Default::default()),
			Err(CallError::MissingCommand("vkGetPipelineCacheData"))
		));
	}
}

#[test]
fn merge_pipeline_caches_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, vk::PipelineCache, &[vk::PipelineCache]) -> Result<(), CallError>;
	let _: Signature = vk::merge_pipeline_caches;
	let _: Signature = vk::Device::merge_pipeline_caches;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::merge_pipeline_caches(&fixture.device, Default::default(), &[]),
			Err(CallError::MissingCommand("vkMergePipelineCaches"))
		));
		assert!(matches!(
			fixture
				.device
				.merge_pipeline_caches(Default::default(), &[]),
			Err(CallError::MissingCommand("vkMergePipelineCaches"))
		));
	}
}

#[test]
fn create_pipeline_binaries_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::PipelineBinaryCreateInfoKHR<'_>,
		*const vk::AllocationCallbacks,
		*mut vk::PipelineBinaryHandlesInfoKHR<'_>,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::create_pipeline_binaries_khr;
	let _: Signature = vk::Device::create_pipeline_binaries_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::create_pipeline_binaries_khr(
				&fixture.device,
				std::mem::zeroed::<*const vk::PipelineBinaryCreateInfoKHR<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::PipelineBinaryHandlesInfoKHR<'_>>()
			),
			Err(CallError::MissingCommand("vkCreatePipelineBinariesKHR"))
		));
		assert!(matches!(
			fixture.device.create_pipeline_binaries_khr(
				std::mem::zeroed::<*const vk::PipelineBinaryCreateInfoKHR<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::PipelineBinaryHandlesInfoKHR<'_>>()
			),
			Err(CallError::MissingCommand("vkCreatePipelineBinariesKHR"))
		));
	}
}

#[test]
fn create_pipeline_binaries_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::PipelineBinaryCreateInfoKHR<'_>,
		arg_2: *const vk::AllocationCallbacks,
		arg_3: *mut vk::PipelineBinaryHandlesInfoKHR<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::PipelineBinaryCreateInfoKHR<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
				) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::PipelineBinaryHandlesInfoKHR<'_>,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCreatePipelineBinariesKHR = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCreatePipelineBinariesKHR, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCreatePipelineBinariesKHR", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::create_pipeline_binaries_khr(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::PipelineBinaryCreateInfoKHR<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::PipelineBinaryHandlesInfoKHR<'_>
				),
				expected
			);
			assert_eq!(
				vk::Device::create_pipeline_binaries_khr(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::PipelineBinaryCreateInfoKHR<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::PipelineBinaryHandlesInfoKHR<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn destroy_pipeline_binary_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::PipelineBinaryKHR,
		*const vk::AllocationCallbacks,
	) -> Result<(), CallError>;
	let _: Signature = vk::destroy_pipeline_binary_khr;
	let _: Signature = vk::Device::destroy_pipeline_binary_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::destroy_pipeline_binary_khr(
				&fixture.device,
				std::mem::zeroed::<vk::PipelineBinaryKHR>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>()
			),
			Err(CallError::MissingCommand("vkDestroyPipelineBinaryKHR"))
		));
		assert!(matches!(
			fixture.device.destroy_pipeline_binary_khr(
				std::mem::zeroed::<vk::PipelineBinaryKHR>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>()
			),
			Err(CallError::MissingCommand("vkDestroyPipelineBinaryKHR"))
		));
	}
}

#[test]
fn destroy_pipeline_binary_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::PipelineBinaryKHR,
		arg_2: *const vk::AllocationCallbacks,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::PipelineBinaryKHR::from_raw(305398016_u64 as _)
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *const vk::AllocationCallbacks,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkDestroyPipelineBinaryKHR = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkDestroyPipelineBinaryKHR, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkDestroyPipelineBinaryKHR", erased);
		let resolutions = Fixture::query_count();
		vk::destroy_pipeline_binary_khr(
			&fixture.device,
			vk::PipelineBinaryKHR::from_raw(305398016_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::AllocationCallbacks,
		)
		.unwrap();
		vk::Device::destroy_pipeline_binary_khr(
			&fixture.device,
			vk::PipelineBinaryKHR::from_raw(305398016_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::AllocationCallbacks,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_pipeline_key_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::PipelineCreateInfoKHR<'_>,
		*mut vk::PipelineBinaryKeyKHR<'_>,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_pipeline_key_khr;
	let _: Signature = vk::Device::get_pipeline_key_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_pipeline_key_khr(
				&fixture.device,
				std::mem::zeroed::<*const vk::PipelineCreateInfoKHR<'_>>(),
				std::mem::zeroed::<*mut vk::PipelineBinaryKeyKHR<'_>>()
			),
			Err(CallError::MissingCommand("vkGetPipelineKeyKHR"))
		));
		assert!(matches!(
			fixture.device.get_pipeline_key_khr(
				std::mem::zeroed::<*const vk::PipelineCreateInfoKHR<'_>>(),
				std::mem::zeroed::<*mut vk::PipelineBinaryKeyKHR<'_>>()
			),
			Err(CallError::MissingCommand("vkGetPipelineKeyKHR"))
		));
	}
}

#[test]
fn get_pipeline_key_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::PipelineCreateInfoKHR<'_>,
		arg_2: *mut vk::PipelineBinaryKeyKHR<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::PipelineCreateInfoKHR<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::PipelineBinaryKeyKHR<'_>,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetPipelineKeyKHR = Some(mock);
		let erased = std::mem::transmute::<vk::PFN_vkGetPipelineKeyKHR, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkGetPipelineKeyKHR", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_pipeline_key_khr(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::PipelineCreateInfoKHR<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::PipelineBinaryKeyKHR<'_>
				),
				expected
			);
			assert_eq!(
				vk::Device::get_pipeline_key_khr(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::PipelineCreateInfoKHR<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::PipelineBinaryKeyKHR<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_pipeline_binary_data_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::PipelineBinaryDataInfoKHR<'_>,
		*mut vk::PipelineBinaryKeyKHR<'_>,
		*mut usize,
		*mut std::ffi::c_void,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_pipeline_binary_data_khr;
	let _: Signature = vk::Device::get_pipeline_binary_data_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_pipeline_binary_data_khr(
				&fixture.device,
				std::mem::zeroed::<*const vk::PipelineBinaryDataInfoKHR<'_>>(),
				std::mem::zeroed::<*mut vk::PipelineBinaryKeyKHR<'_>>(),
				std::mem::zeroed::<*mut usize>(),
				std::mem::zeroed::<*mut std::ffi::c_void>()
			),
			Err(CallError::MissingCommand("vkGetPipelineBinaryDataKHR"))
		));
		assert!(matches!(
			fixture.device.get_pipeline_binary_data_khr(
				std::mem::zeroed::<*const vk::PipelineBinaryDataInfoKHR<'_>>(),
				std::mem::zeroed::<*mut vk::PipelineBinaryKeyKHR<'_>>(),
				std::mem::zeroed::<*mut usize>(),
				std::mem::zeroed::<*mut std::ffi::c_void>()
			),
			Err(CallError::MissingCommand("vkGetPipelineBinaryDataKHR"))
		));
	}
}

#[test]
fn get_pipeline_binary_data_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::PipelineBinaryDataInfoKHR<'_>,
		arg_2: *mut vk::PipelineBinaryKeyKHR<'_>,
		arg_3: *mut usize,
		arg_4: *mut std::ffi::c_void,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::PipelineBinaryDataInfoKHR<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::PipelineBinaryKeyKHR<'_>,
				) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut usize,
				) && std::ptr::eq(
					arg_4,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784),
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetPipelineBinaryDataKHR = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkGetPipelineBinaryDataKHR, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkGetPipelineBinaryDataKHR", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_pipeline_binary_data_khr(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::PipelineBinaryDataInfoKHR<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::PipelineBinaryKeyKHR<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut usize,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784)
				),
				expected
			);
			assert_eq!(
				vk::Device::get_pipeline_binary_data_khr(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::PipelineBinaryDataInfoKHR<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::PipelineBinaryKeyKHR<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut usize,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784)
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn release_captured_pipeline_data_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::ReleaseCapturedPipelineDataInfoKHR<'_>,
		*const vk::AllocationCallbacks,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::release_captured_pipeline_data_khr;
	let _: Signature = vk::Device::release_captured_pipeline_data_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::release_captured_pipeline_data_khr(
				&fixture.device,
				std::mem::zeroed::<*const vk::ReleaseCapturedPipelineDataInfoKHR<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>()
			),
			Err(CallError::MissingCommand(
				"vkReleaseCapturedPipelineDataKHR"
			))
		));
		assert!(matches!(
			fixture.device.release_captured_pipeline_data_khr(
				std::mem::zeroed::<*const vk::ReleaseCapturedPipelineDataInfoKHR<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>()
			),
			Err(CallError::MissingCommand(
				"vkReleaseCapturedPipelineDataKHR"
			))
		));
	}
}

#[test]
fn release_captured_pipeline_data_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::ReleaseCapturedPipelineDataInfoKHR<'_>,
		arg_2: *const vk::AllocationCallbacks,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::ReleaseCapturedPipelineDataInfoKHR<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkReleaseCapturedPipelineDataKHR = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkReleaseCapturedPipelineDataKHR,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkReleaseCapturedPipelineDataKHR", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::release_captured_pipeline_data_khr(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::ReleaseCapturedPipelineDataInfoKHR<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks
				),
				expected
			);
			assert_eq!(
				vk::Device::release_captured_pipeline_data_khr(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::ReleaseCapturedPipelineDataInfoKHR<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn create_graphics_pipelines_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::PipelineCache,
		&[vk::GraphicsPipelineCreateInfo<'_>],
		Option<&vk::AllocationCallbacks>,
		&mut [vk::Pipeline],
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::create_graphics_pipelines;
	let _: Signature = vk::Device::create_graphics_pipelines;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::create_graphics_pipelines(&fixture.device, Default::default(), &[], None, &mut []),
			Err(CallError::MissingCommand("vkCreateGraphicsPipelines"))
		));
		assert!(matches!(
			fixture
				.device
				.create_graphics_pipelines(Default::default(), &[], None, &mut []),
			Err(CallError::MissingCommand("vkCreateGraphicsPipelines"))
		));
	}
}

#[test]
fn create_compute_pipelines_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::PipelineCache,
		&[vk::ComputePipelineCreateInfo<'_>],
		Option<&vk::AllocationCallbacks>,
		&mut [vk::Pipeline],
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::create_compute_pipelines;
	let _: Signature = vk::Device::create_compute_pipelines;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::create_compute_pipelines(&fixture.device, Default::default(), &[], None, &mut []),
			Err(CallError::MissingCommand("vkCreateComputePipelines"))
		));
		assert!(matches!(
			fixture
				.device
				.create_compute_pipelines(Default::default(), &[], None, &mut []),
			Err(CallError::MissingCommand("vkCreateComputePipelines"))
		));
	}
}

#[test]
fn get_device_subpass_shading_max_workgroup_size_huawei_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, vk::RenderPass, *mut vk::Extent2D) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_device_subpass_shading_max_workgroup_size_huawei;
	let _: Signature = vk::Device::get_device_subpass_shading_max_workgroup_size_huawei;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_device_subpass_shading_max_workgroup_size_huawei(
				&fixture.device,
				std::mem::zeroed::<vk::RenderPass>(),
				std::mem::zeroed::<*mut vk::Extent2D>()
			),
			Err(CallError::MissingCommand(
				"vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI"
			))
		));
		assert!(matches!(
			fixture
				.device
				.get_device_subpass_shading_max_workgroup_size_huawei(
					std::mem::zeroed::<vk::RenderPass>(),
					std::mem::zeroed::<*mut vk::Extent2D>()
				),
			Err(CallError::MissingCommand(
				"vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI"
			))
		));
	}
}

#[test]
fn get_device_subpass_shading_max_workgroup_size_huawei_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::RenderPass,
		arg_2: *mut vk::Extent2D,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::RenderPass::from_raw(305398016_u64 as _)
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut vk::Extent2D,
					)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture =
			Fixture::new_with_command(c"vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_device_subpass_shading_max_workgroup_size_huawei(
					&fixture.device,
					vk::RenderPass::from_raw(305398016_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut vk::Extent2D
				),
				expected
			);
			assert_eq!(
				vk::Device::get_device_subpass_shading_max_workgroup_size_huawei(
					&fixture.device,
					vk::RenderPass::from_raw(305398016_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut vk::Extent2D
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn destroy_pipeline_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, vk::Pipeline, Option<&vk::AllocationCallbacks>) -> Result<(), CallError>;
	let _: Signature = vk::destroy_pipeline;
	let _: Signature = vk::Device::destroy_pipeline;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::destroy_pipeline(&fixture.device, Default::default(), None),
			Err(CallError::MissingCommand("vkDestroyPipeline"))
		));
		assert!(matches!(
			fixture.device.destroy_pipeline(Default::default(), None),
			Err(CallError::MissingCommand("vkDestroyPipeline"))
		));
	}
}

#[test]
fn create_pipeline_layout_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		&vk::PipelineLayoutCreateInfo<'_>,
		Option<&vk::AllocationCallbacks>,
	) -> Result<vk::PipelineLayout, CallError>;
	let _: Signature = vk::create_pipeline_layout;
	let _: Signature = vk::Device::create_pipeline_layout;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::create_pipeline_layout(
				&fixture.device,
				&std::mem::zeroed::<vk::PipelineLayoutCreateInfo<'_>>(),
				None
			),
			Err(CallError::MissingCommand("vkCreatePipelineLayout"))
		));
		assert!(matches!(
			fixture.device.create_pipeline_layout(
				&std::mem::zeroed::<vk::PipelineLayoutCreateInfo<'_>>(),
				None
			),
			Err(CallError::MissingCommand("vkCreatePipelineLayout"))
		));
	}
}

#[test]
fn destroy_pipeline_layout_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::PipelineLayout,
		Option<&vk::AllocationCallbacks>,
	) -> Result<(), CallError>;
	let _: Signature = vk::destroy_pipeline_layout;
	let _: Signature = vk::Device::destroy_pipeline_layout;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::destroy_pipeline_layout(&fixture.device, Default::default(), None),
			Err(CallError::MissingCommand("vkDestroyPipelineLayout"))
		));
		assert!(matches!(
			fixture
				.device
				.destroy_pipeline_layout(Default::default(), None),
			Err(CallError::MissingCommand("vkDestroyPipelineLayout"))
		));
	}
}

#[test]
fn create_sampler_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		&vk::SamplerCreateInfo<'_>,
		Option<&vk::AllocationCallbacks>,
	) -> Result<vk::Sampler, CallError>;
	let _: Signature = vk::create_sampler;
	let _: Signature = vk::Device::create_sampler;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::create_sampler(
				&fixture.device,
				&std::mem::zeroed::<vk::SamplerCreateInfo<'_>>(),
				None
			),
			Err(CallError::MissingCommand("vkCreateSampler"))
		));
		assert!(matches!(
			fixture
				.device
				.create_sampler(&std::mem::zeroed::<vk::SamplerCreateInfo<'_>>(), None),
			Err(CallError::MissingCommand("vkCreateSampler"))
		));
	}
}

#[test]
fn destroy_sampler_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, vk::Sampler, Option<&vk::AllocationCallbacks>) -> Result<(), CallError>;
	let _: Signature = vk::destroy_sampler;
	let _: Signature = vk::Device::destroy_sampler;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::destroy_sampler(&fixture.device, Default::default(), None),
			Err(CallError::MissingCommand("vkDestroySampler"))
		));
		assert!(matches!(
			fixture.device.destroy_sampler(Default::default(), None),
			Err(CallError::MissingCommand("vkDestroySampler"))
		));
	}
}

#[test]
fn create_descriptor_set_layout_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		&vk::DescriptorSetLayoutCreateInfo<'_>,
		Option<&vk::AllocationCallbacks>,
	) -> Result<vk::DescriptorSetLayout, CallError>;
	let _: Signature = vk::create_descriptor_set_layout;
	let _: Signature = vk::Device::create_descriptor_set_layout;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::create_descriptor_set_layout(
				&fixture.device,
				&std::mem::zeroed::<vk::DescriptorSetLayoutCreateInfo<'_>>(),
				None
			),
			Err(CallError::MissingCommand("vkCreateDescriptorSetLayout"))
		));
		assert!(matches!(
			fixture.device.create_descriptor_set_layout(
				&std::mem::zeroed::<vk::DescriptorSetLayoutCreateInfo<'_>>(),
				None
			),
			Err(CallError::MissingCommand("vkCreateDescriptorSetLayout"))
		));
	}
}

#[test]
fn destroy_descriptor_set_layout_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::DescriptorSetLayout,
		Option<&vk::AllocationCallbacks>,
	) -> Result<(), CallError>;
	let _: Signature = vk::destroy_descriptor_set_layout;
	let _: Signature = vk::Device::destroy_descriptor_set_layout;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::destroy_descriptor_set_layout(&fixture.device, Default::default(), None),
			Err(CallError::MissingCommand("vkDestroyDescriptorSetLayout"))
		));
		assert!(matches!(
			fixture
				.device
				.destroy_descriptor_set_layout(Default::default(), None),
			Err(CallError::MissingCommand("vkDestroyDescriptorSetLayout"))
		));
	}
}

#[test]
fn create_descriptor_pool_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		&vk::DescriptorPoolCreateInfo<'_>,
		Option<&vk::AllocationCallbacks>,
	) -> Result<vk::DescriptorPool, CallError>;
	let _: Signature = vk::create_descriptor_pool;
	let _: Signature = vk::Device::create_descriptor_pool;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::create_descriptor_pool(
				&fixture.device,
				&std::mem::zeroed::<vk::DescriptorPoolCreateInfo<'_>>(),
				None
			),
			Err(CallError::MissingCommand("vkCreateDescriptorPool"))
		));
		assert!(matches!(
			fixture.device.create_descriptor_pool(
				&std::mem::zeroed::<vk::DescriptorPoolCreateInfo<'_>>(),
				None
			),
			Err(CallError::MissingCommand("vkCreateDescriptorPool"))
		));
	}
}

#[test]
fn destroy_descriptor_pool_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::DescriptorPool,
		Option<&vk::AllocationCallbacks>,
	) -> Result<(), CallError>;
	let _: Signature = vk::destroy_descriptor_pool;
	let _: Signature = vk::Device::destroy_descriptor_pool;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::destroy_descriptor_pool(&fixture.device, Default::default(), None),
			Err(CallError::MissingCommand("vkDestroyDescriptorPool"))
		));
		assert!(matches!(
			fixture
				.device
				.destroy_descriptor_pool(Default::default(), None),
			Err(CallError::MissingCommand("vkDestroyDescriptorPool"))
		));
	}
}

#[test]
fn reset_descriptor_pool_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::DescriptorPool,
		vk::DescriptorPoolResetFlags,
	) -> Result<(), CallError>;
	let _: Signature = vk::reset_descriptor_pool;
	let _: Signature = vk::Device::reset_descriptor_pool;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::reset_descriptor_pool(&fixture.device, Default::default(), Default::default()),
			Err(CallError::MissingCommand("vkResetDescriptorPool"))
		));
		assert!(matches!(
			fixture
				.device
				.reset_descriptor_pool(Default::default(), Default::default()),
			Err(CallError::MissingCommand("vkResetDescriptorPool"))
		));
	}
}

#[test]
fn allocate_descriptor_sets_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		&vk::DescriptorSetAllocateInfo<'_>,
		&mut [vk::DescriptorSet],
	) -> Result<(), CallError>;
	let _: Signature = vk::allocate_descriptor_sets;
	let _: Signature = vk::Device::allocate_descriptor_sets;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::allocate_descriptor_sets(
				&fixture.device,
				&std::mem::zeroed::<vk::DescriptorSetAllocateInfo<'_>>(),
				&mut []
			),
			Err(CallError::MissingCommand("vkAllocateDescriptorSets"))
		));
		assert!(matches!(
			fixture.device.allocate_descriptor_sets(
				&std::mem::zeroed::<vk::DescriptorSetAllocateInfo<'_>>(),
				&mut []
			),
			Err(CallError::MissingCommand("vkAllocateDescriptorSets"))
		));
	}
}

#[test]
fn free_descriptor_sets_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, vk::DescriptorPool, &[vk::DescriptorSet]) -> Result<(), CallError>;
	let _: Signature = vk::free_descriptor_sets;
	let _: Signature = vk::Device::free_descriptor_sets;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::free_descriptor_sets(&fixture.device, Default::default(), &[]),
			Err(CallError::MissingCommand("vkFreeDescriptorSets"))
		));
		assert!(matches!(
			fixture.device.free_descriptor_sets(Default::default(), &[]),
			Err(CallError::MissingCommand("vkFreeDescriptorSets"))
		));
	}
}

#[test]
fn update_descriptor_sets_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		&[vk::WriteDescriptorSet<'_>],
		&[vk::CopyDescriptorSet<'_>],
	) -> Result<(), CallError>;
	let _: Signature = vk::update_descriptor_sets;
	let _: Signature = vk::Device::update_descriptor_sets;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::update_descriptor_sets(&fixture.device, &[], &[]),
			Err(CallError::MissingCommand("vkUpdateDescriptorSets"))
		));
		assert!(matches!(
			fixture.device.update_descriptor_sets(&[], &[]),
			Err(CallError::MissingCommand("vkUpdateDescriptorSets"))
		));
	}
}

#[test]
fn create_framebuffer_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		&vk::FramebufferCreateInfo<'_>,
		Option<&vk::AllocationCallbacks>,
	) -> Result<vk::Framebuffer, CallError>;
	let _: Signature = vk::create_framebuffer;
	let _: Signature = vk::Device::create_framebuffer;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::create_framebuffer(
				&fixture.device,
				&std::mem::zeroed::<vk::FramebufferCreateInfo<'_>>(),
				None
			),
			Err(CallError::MissingCommand("vkCreateFramebuffer"))
		));
		assert!(matches!(
			fixture
				.device
				.create_framebuffer(&std::mem::zeroed::<vk::FramebufferCreateInfo<'_>>(), None),
			Err(CallError::MissingCommand("vkCreateFramebuffer"))
		));
	}
}

#[test]
fn destroy_framebuffer_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::Framebuffer,
		Option<&vk::AllocationCallbacks>,
	) -> Result<(), CallError>;
	let _: Signature = vk::destroy_framebuffer;
	let _: Signature = vk::Device::destroy_framebuffer;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::destroy_framebuffer(&fixture.device, Default::default(), None),
			Err(CallError::MissingCommand("vkDestroyFramebuffer"))
		));
		assert!(matches!(
			fixture.device.destroy_framebuffer(Default::default(), None),
			Err(CallError::MissingCommand("vkDestroyFramebuffer"))
		));
	}
}

#[test]
fn create_render_pass_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		&vk::RenderPassCreateInfo<'_>,
		Option<&vk::AllocationCallbacks>,
	) -> Result<vk::RenderPass, CallError>;
	let _: Signature = vk::create_render_pass;
	let _: Signature = vk::Device::create_render_pass;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::create_render_pass(
				&fixture.device,
				&std::mem::zeroed::<vk::RenderPassCreateInfo<'_>>(),
				None
			),
			Err(CallError::MissingCommand("vkCreateRenderPass"))
		));
		assert!(matches!(
			fixture
				.device
				.create_render_pass(&std::mem::zeroed::<vk::RenderPassCreateInfo<'_>>(), None),
			Err(CallError::MissingCommand("vkCreateRenderPass"))
		));
	}
}

#[test]
fn destroy_render_pass_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::RenderPass,
		Option<&vk::AllocationCallbacks>,
	) -> Result<(), CallError>;
	let _: Signature = vk::destroy_render_pass;
	let _: Signature = vk::Device::destroy_render_pass;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::destroy_render_pass(&fixture.device, Default::default(), None),
			Err(CallError::MissingCommand("vkDestroyRenderPass"))
		));
		assert!(matches!(
			fixture.device.destroy_render_pass(Default::default(), None),
			Err(CallError::MissingCommand("vkDestroyRenderPass"))
		));
	}
}

#[test]
fn get_render_area_granularity_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, vk::RenderPass, &mut vk::Extent2D) -> Result<(), CallError>;
	let _: Signature = vk::get_render_area_granularity;
	let _: Signature = vk::Device::get_render_area_granularity;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_render_area_granularity(
				&fixture.device,
				Default::default(),
				&mut std::mem::zeroed::<vk::Extent2D>()
			),
			Err(CallError::MissingCommand("vkGetRenderAreaGranularity"))
		));
		assert!(matches!(
			fixture
				.device
				.get_render_area_granularity(Default::default(), &mut std::mem::zeroed::<vk::Extent2D>()),
			Err(CallError::MissingCommand("vkGetRenderAreaGranularity"))
		));
	}
}

#[test]
fn get_rendering_area_granularity_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::RenderingAreaInfo<'_>,
		*mut vk::Extent2D,
	) -> Result<(), CallError>;
	let _: Signature = vk::get_rendering_area_granularity;
	let _: Signature = vk::Device::get_rendering_area_granularity;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_rendering_area_granularity(
				&fixture.device,
				std::mem::zeroed::<*const vk::RenderingAreaInfo<'_>>(),
				std::mem::zeroed::<*mut vk::Extent2D>()
			),
			Err(CallError::MissingCommand("vkGetRenderingAreaGranularity"))
		));
		assert!(matches!(
			fixture.device.get_rendering_area_granularity(
				std::mem::zeroed::<*const vk::RenderingAreaInfo<'_>>(),
				std::mem::zeroed::<*mut vk::Extent2D>()
			),
			Err(CallError::MissingCommand("vkGetRenderingAreaGranularity"))
		));
	}
}

#[test]
fn get_rendering_area_granularity_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::RenderingAreaInfo<'_>,
		arg_2: *mut vk::Extent2D,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::RenderingAreaInfo<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut vk::Extent2D,
				)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetRenderingAreaGranularity = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkGetRenderingAreaGranularity, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkGetRenderingAreaGranularity", erased);
		let resolutions = Fixture::query_count();
		vk::get_rendering_area_granularity(
			&fixture.device,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::RenderingAreaInfo<'_>,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut vk::Extent2D,
		)
		.unwrap();
		vk::Device::get_rendering_area_granularity(
			&fixture.device,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::RenderingAreaInfo<'_>,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut vk::Extent2D,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_rendering_area_granularity_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::RenderingAreaInfo<'_>,
		*mut vk::Extent2D,
	) -> Result<(), CallError>;
	let _: Signature = vk::get_rendering_area_granularity_khr;
	let _: Signature = vk::Device::get_rendering_area_granularity_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_rendering_area_granularity_khr(
				&fixture.device,
				std::mem::zeroed::<*const vk::RenderingAreaInfo<'_>>(),
				std::mem::zeroed::<*mut vk::Extent2D>()
			),
			Err(CallError::MissingCommand(
				"vkGetRenderingAreaGranularityKHR"
			))
		));
		assert!(matches!(
			fixture.device.get_rendering_area_granularity_khr(
				std::mem::zeroed::<*const vk::RenderingAreaInfo<'_>>(),
				std::mem::zeroed::<*mut vk::Extent2D>()
			),
			Err(CallError::MissingCommand(
				"vkGetRenderingAreaGranularityKHR"
			))
		));
	}
}

#[test]
fn get_rendering_area_granularity_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::RenderingAreaInfo<'_>,
		arg_2: *mut vk::Extent2D,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::RenderingAreaInfo<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut vk::Extent2D,
				)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetRenderingAreaGranularityKHR = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetRenderingAreaGranularityKHR,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkGetRenderingAreaGranularityKHR", erased);
		let resolutions = Fixture::query_count();
		vk::get_rendering_area_granularity_khr(
			&fixture.device,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::RenderingAreaInfo<'_>,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut vk::Extent2D,
		)
		.unwrap();
		vk::Device::get_rendering_area_granularity_khr(
			&fixture.device,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::RenderingAreaInfo<'_>,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut vk::Extent2D,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn reset_command_pool_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, vk::CommandPool, vk::CommandPoolResetFlags) -> Result<(), CallError>;
	let _: Signature = vk::reset_command_pool;
	let _: Signature = vk::Device::reset_command_pool;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::reset_command_pool(&fixture.device, Default::default(), Default::default()),
			Err(CallError::MissingCommand("vkResetCommandPool"))
		));
		assert!(matches!(
			fixture
				.device
				.reset_command_pool(Default::default(), Default::default()),
			Err(CallError::MissingCommand("vkResetCommandPool"))
		));
	}
}

#[test]
fn reset_command_buffer_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, vk::CommandBuffer, vk::CommandBufferResetFlags) -> Result<(), CallError>;
	let _: Signature = vk::reset_command_buffer;
	let _: Signature = vk::Device::reset_command_buffer;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::reset_command_buffer(&fixture.device, Default::default(), Default::default()),
			Err(CallError::MissingCommand("vkResetCommandBuffer"))
		));
		assert!(matches!(
			fixture
				.device
				.reset_command_buffer(Default::default(), Default::default()),
			Err(CallError::MissingCommand("vkResetCommandBuffer"))
		));
	}
}

#[test]
fn cmd_bind_pipeline_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		vk::PipelineBindPoint,
		vk::Pipeline,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_bind_pipeline;
	let _: Signature = vk::Device::cmd_bind_pipeline;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_bind_pipeline(
				&fixture.device,
				Default::default(),
				Default::default(),
				Default::default()
			),
			Err(CallError::MissingCommand("vkCmdBindPipeline"))
		));
		assert!(matches!(
			fixture
				.device
				.cmd_bind_pipeline(Default::default(), Default::default(), Default::default()),
			Err(CallError::MissingCommand("vkCmdBindPipeline"))
		));
	}
}

#[test]
fn cmd_set_primitive_restart_index_ext_signature_and_missing_command() {
	type Signature = unsafe fn(&vk::Device, vk::CommandBuffer, u32) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_primitive_restart_index_ext;
	let _: Signature = vk::Device::cmd_set_primitive_restart_index_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_primitive_restart_index_ext(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>()
			),
			Err(CallError::MissingCommand(
				"vkCmdSetPrimitiveRestartIndexEXT"
			))
		));
		assert!(matches!(
			fixture.device.cmd_set_primitive_restart_index_ext(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>()
			),
			Err(CallError::MissingCommand(
				"vkCmdSetPrimitiveRestartIndexEXT"
			))
		));
	}
}

#[test]
fn cmd_set_primitive_restart_index_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::CommandBuffer, arg_1: u32) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == Default::default()),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdSetPrimitiveRestartIndexEXT = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkCmdSetPrimitiveRestartIndexEXT,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdSetPrimitiveRestartIndexEXT", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_set_primitive_restart_index_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
		)
		.unwrap();
		vk::Device::cmd_set_primitive_restart_index_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_set_attachment_feedback_loop_enable_ext_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, vk::CommandBuffer, vk::ImageAspectFlags) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_attachment_feedback_loop_enable_ext;
	let _: Signature = vk::Device::cmd_set_attachment_feedback_loop_enable_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_attachment_feedback_loop_enable_ext(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::ImageAspectFlags>()
			),
			Err(CallError::MissingCommand(
				"vkCmdSetAttachmentFeedbackLoopEnableEXT"
			))
		));
		assert!(matches!(
			fixture.device.cmd_set_attachment_feedback_loop_enable_ext(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::ImageAspectFlags>()
			),
			Err(CallError::MissingCommand(
				"vkCmdSetAttachmentFeedbackLoopEnableEXT"
			))
		));
	}
}

#[test]
fn cmd_set_attachment_feedback_loop_enable_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::CommandBuffer, arg_1: vk::ImageAspectFlags) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == vk::ImageAspectFlags::from_raw(305398016_u64 as _)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdSetAttachmentFeedbackLoopEnableEXT = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkCmdSetAttachmentFeedbackLoopEnableEXT,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdSetAttachmentFeedbackLoopEnableEXT", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_set_attachment_feedback_loop_enable_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::ImageAspectFlags::from_raw(305398016_u64 as _),
		)
		.unwrap();
		vk::Device::cmd_set_attachment_feedback_loop_enable_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::ImageAspectFlags::from_raw(305398016_u64 as _),
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_set_viewport_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, vk::CommandBuffer, u32, &[vk::Viewport]) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_viewport;
	let _: Signature = vk::Device::cmd_set_viewport;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_viewport(&fixture.device, Default::default(), Default::default(), &[]),
			Err(CallError::MissingCommand("vkCmdSetViewport"))
		));
		assert!(matches!(
			fixture
				.device
				.cmd_set_viewport(Default::default(), Default::default(), &[]),
			Err(CallError::MissingCommand("vkCmdSetViewport"))
		));
	}
}

#[test]
fn cmd_set_scissor_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, vk::CommandBuffer, u32, &[vk::Rect2D]) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_scissor;
	let _: Signature = vk::Device::cmd_set_scissor;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_scissor(&fixture.device, Default::default(), Default::default(), &[]),
			Err(CallError::MissingCommand("vkCmdSetScissor"))
		));
		assert!(matches!(
			fixture
				.device
				.cmd_set_scissor(Default::default(), Default::default(), &[]),
			Err(CallError::MissingCommand("vkCmdSetScissor"))
		));
	}
}

#[test]
fn cmd_set_line_width_signature_and_missing_command() {
	type Signature = unsafe fn(&vk::Device, vk::CommandBuffer, f32) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_line_width;
	let _: Signature = vk::Device::cmd_set_line_width;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_line_width(&fixture.device, Default::default(), Default::default()),
			Err(CallError::MissingCommand("vkCmdSetLineWidth"))
		));
		assert!(matches!(
			fixture
				.device
				.cmd_set_line_width(Default::default(), Default::default()),
			Err(CallError::MissingCommand("vkCmdSetLineWidth"))
		));
	}
}

#[test]
fn cmd_set_depth_bias_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, vk::CommandBuffer, f32, f32, f32) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_depth_bias;
	let _: Signature = vk::Device::cmd_set_depth_bias;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_depth_bias(
				&fixture.device,
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default()
			),
			Err(CallError::MissingCommand("vkCmdSetDepthBias"))
		));
		assert!(matches!(
			fixture.device.cmd_set_depth_bias(
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default()
			),
			Err(CallError::MissingCommand("vkCmdSetDepthBias"))
		));
	}
}

#[test]
fn cmd_set_blend_constants_signature_and_missing_command() {
	type Signature = unsafe fn(&vk::Device, vk::CommandBuffer, &[f32; 4]) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_blend_constants;
	let _: Signature = vk::Device::cmd_set_blend_constants;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_blend_constants(
				&fixture.device,
				Default::default(),
				&[Default::default(); 4]
			),
			Err(CallError::MissingCommand("vkCmdSetBlendConstants"))
		));
		assert!(matches!(
			fixture
				.device
				.cmd_set_blend_constants(Default::default(), &[Default::default(); 4]),
			Err(CallError::MissingCommand("vkCmdSetBlendConstants"))
		));
	}
}

#[test]
fn cmd_set_depth_bounds_signature_and_missing_command() {
	type Signature = unsafe fn(&vk::Device, vk::CommandBuffer, f32, f32) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_depth_bounds;
	let _: Signature = vk::Device::cmd_set_depth_bounds;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_depth_bounds(
				&fixture.device,
				Default::default(),
				Default::default(),
				Default::default()
			),
			Err(CallError::MissingCommand("vkCmdSetDepthBounds"))
		));
		assert!(matches!(
			fixture.device.cmd_set_depth_bounds(
				Default::default(),
				Default::default(),
				Default::default()
			),
			Err(CallError::MissingCommand("vkCmdSetDepthBounds"))
		));
	}
}

#[test]
fn cmd_set_stencil_compare_mask_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, vk::CommandBuffer, vk::StencilFaceFlags, u32) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_stencil_compare_mask;
	let _: Signature = vk::Device::cmd_set_stencil_compare_mask;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_stencil_compare_mask(
				&fixture.device,
				Default::default(),
				Default::default(),
				Default::default()
			),
			Err(CallError::MissingCommand("vkCmdSetStencilCompareMask"))
		));
		assert!(matches!(
			fixture.device.cmd_set_stencil_compare_mask(
				Default::default(),
				Default::default(),
				Default::default()
			),
			Err(CallError::MissingCommand("vkCmdSetStencilCompareMask"))
		));
	}
}

#[test]
fn cmd_set_stencil_write_mask_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, vk::CommandBuffer, vk::StencilFaceFlags, u32) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_stencil_write_mask;
	let _: Signature = vk::Device::cmd_set_stencil_write_mask;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_stencil_write_mask(
				&fixture.device,
				Default::default(),
				Default::default(),
				Default::default()
			),
			Err(CallError::MissingCommand("vkCmdSetStencilWriteMask"))
		));
		assert!(matches!(
			fixture.device.cmd_set_stencil_write_mask(
				Default::default(),
				Default::default(),
				Default::default()
			),
			Err(CallError::MissingCommand("vkCmdSetStencilWriteMask"))
		));
	}
}

#[test]
fn cmd_set_stencil_reference_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, vk::CommandBuffer, vk::StencilFaceFlags, u32) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_stencil_reference;
	let _: Signature = vk::Device::cmd_set_stencil_reference;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_stencil_reference(
				&fixture.device,
				Default::default(),
				Default::default(),
				Default::default()
			),
			Err(CallError::MissingCommand("vkCmdSetStencilReference"))
		));
		assert!(matches!(
			fixture.device.cmd_set_stencil_reference(
				Default::default(),
				Default::default(),
				Default::default()
			),
			Err(CallError::MissingCommand("vkCmdSetStencilReference"))
		));
	}
}

#[test]
fn cmd_bind_descriptor_sets_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		vk::PipelineBindPoint,
		vk::PipelineLayout,
		u32,
		&[vk::DescriptorSet],
		&[u32],
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_bind_descriptor_sets;
	let _: Signature = vk::Device::cmd_bind_descriptor_sets;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_bind_descriptor_sets(
				&fixture.device,
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default(),
				&[],
				&[]
			),
			Err(CallError::MissingCommand("vkCmdBindDescriptorSets"))
		));
		assert!(matches!(
			fixture.device.cmd_bind_descriptor_sets(
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default(),
				&[],
				&[]
			),
			Err(CallError::MissingCommand("vkCmdBindDescriptorSets"))
		));
	}
}

#[test]
fn cmd_bind_index_buffer_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		vk::Buffer,
		vk::DeviceSize,
		vk::IndexType,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_bind_index_buffer;
	let _: Signature = vk::Device::cmd_bind_index_buffer;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_bind_index_buffer(
				&fixture.device,
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default()
			),
			Err(CallError::MissingCommand("vkCmdBindIndexBuffer"))
		));
		assert!(matches!(
			fixture.device.cmd_bind_index_buffer(
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default()
			),
			Err(CallError::MissingCommand("vkCmdBindIndexBuffer"))
		));
	}
}

#[test]
fn cmd_bind_vertex_buffers_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		u32,
		&[vk::Buffer],
		&[vk::DeviceSize],
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_bind_vertex_buffers;
	let _: Signature = vk::Device::cmd_bind_vertex_buffers;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_bind_vertex_buffers(
				&fixture.device,
				Default::default(),
				Default::default(),
				&[],
				&[]
			),
			Err(CallError::MissingCommand("vkCmdBindVertexBuffers"))
		));
		assert!(matches!(
			fixture
				.device
				.cmd_bind_vertex_buffers(Default::default(), Default::default(), &[], &[]),
			Err(CallError::MissingCommand("vkCmdBindVertexBuffers"))
		));
	}
}

#[test]
fn cmd_draw_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, vk::CommandBuffer, u32, u32, u32, u32) -> Result<(), CallError>;
	let _: Signature = vk::cmd_draw;
	let _: Signature = vk::Device::cmd_draw;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_draw(
				&fixture.device,
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default()
			),
			Err(CallError::MissingCommand("vkCmdDraw"))
		));
		assert!(matches!(
			fixture.device.cmd_draw(
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default()
			),
			Err(CallError::MissingCommand("vkCmdDraw"))
		));
	}
}

#[test]
fn cmd_draw_indexed_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, vk::CommandBuffer, u32, u32, u32, i32, u32) -> Result<(), CallError>;
	let _: Signature = vk::cmd_draw_indexed;
	let _: Signature = vk::Device::cmd_draw_indexed;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_draw_indexed(
				&fixture.device,
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default()
			),
			Err(CallError::MissingCommand("vkCmdDrawIndexed"))
		));
		assert!(matches!(
			fixture.device.cmd_draw_indexed(
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default()
			),
			Err(CallError::MissingCommand("vkCmdDrawIndexed"))
		));
	}
}

#[test]
fn cmd_draw_multi_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		u32,
		*const vk::MultiDrawInfoEXT,
		u32,
		u32,
		u32,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_draw_multi_ext;
	let _: Signature = vk::Device::cmd_draw_multi_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_draw_multi_ext(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::MultiDrawInfoEXT>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>()
			),
			Err(CallError::MissingCommand("vkCmdDrawMultiEXT"))
		));
		assert!(matches!(
			fixture.device.cmd_draw_multi_ext(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::MultiDrawInfoEXT>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>()
			),
			Err(CallError::MissingCommand("vkCmdDrawMultiEXT"))
		));
	}
}

#[test]
fn cmd_draw_multi_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: u32,
		arg_2: *const vk::MultiDrawInfoEXT,
		arg_3: u32,
		arg_4: u32,
		arg_5: u32,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == Default::default()
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *const vk::MultiDrawInfoEXT,
					) && arg_3 == Default::default()
					&& arg_4 == Default::default()
					&& arg_5 == Default::default()),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdDrawMultiEXT = Some(mock);
		let erased = std::mem::transmute::<vk::PFN_vkCmdDrawMultiEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdDrawMultiEXT", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_draw_multi_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::MultiDrawInfoEXT,
			Default::default(),
			Default::default(),
			Default::default(),
		)
		.unwrap();
		vk::Device::cmd_draw_multi_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::MultiDrawInfoEXT,
			Default::default(),
			Default::default(),
			Default::default(),
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_draw_multi_indexed_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		u32,
		*const vk::MultiDrawIndexedInfoEXT,
		u32,
		u32,
		u32,
		*const i32,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_draw_multi_indexed_ext;
	let _: Signature = vk::Device::cmd_draw_multi_indexed_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_draw_multi_indexed_ext(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::MultiDrawIndexedInfoEXT>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const i32>()
			),
			Err(CallError::MissingCommand("vkCmdDrawMultiIndexedEXT"))
		));
		assert!(matches!(
			fixture.device.cmd_draw_multi_indexed_ext(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::MultiDrawIndexedInfoEXT>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const i32>()
			),
			Err(CallError::MissingCommand("vkCmdDrawMultiIndexedEXT"))
		));
	}
}

#[test]
fn cmd_draw_multi_indexed_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: u32,
		arg_2: *const vk::MultiDrawIndexedInfoEXT,
		arg_3: u32,
		arg_4: u32,
		arg_5: u32,
		arg_6: *const i32,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == Default::default()
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *const vk::MultiDrawIndexedInfoEXT,
					) && arg_3 == Default::default()
					&& arg_4 == Default::default()
					&& arg_5 == Default::default()
					&& std::ptr::eq(
						arg_6,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305399296) as *const i32,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdDrawMultiIndexedEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdDrawMultiIndexedEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdDrawMultiIndexedEXT", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_draw_multi_indexed_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::MultiDrawIndexedInfoEXT,
			Default::default(),
			Default::default(),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305399296) as *const i32,
		)
		.unwrap();
		vk::Device::cmd_draw_multi_indexed_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::MultiDrawIndexedInfoEXT,
			Default::default(),
			Default::default(),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305399296) as *const i32,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_draw_indirect_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		vk::Buffer,
		vk::DeviceSize,
		u32,
		u32,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_draw_indirect;
	let _: Signature = vk::Device::cmd_draw_indirect;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_draw_indirect(
				&fixture.device,
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default()
			),
			Err(CallError::MissingCommand("vkCmdDrawIndirect"))
		));
		assert!(matches!(
			fixture.device.cmd_draw_indirect(
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default()
			),
			Err(CallError::MissingCommand("vkCmdDrawIndirect"))
		));
	}
}

#[test]
fn cmd_draw_indexed_indirect_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		vk::Buffer,
		vk::DeviceSize,
		u32,
		u32,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_draw_indexed_indirect;
	let _: Signature = vk::Device::cmd_draw_indexed_indirect;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_draw_indexed_indirect(
				&fixture.device,
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default()
			),
			Err(CallError::MissingCommand("vkCmdDrawIndexedIndirect"))
		));
		assert!(matches!(
			fixture.device.cmd_draw_indexed_indirect(
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default()
			),
			Err(CallError::MissingCommand("vkCmdDrawIndexedIndirect"))
		));
	}
}

#[test]
fn cmd_dispatch_indirect_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, vk::CommandBuffer, vk::Buffer, vk::DeviceSize) -> Result<(), CallError>;
	let _: Signature = vk::cmd_dispatch_indirect;
	let _: Signature = vk::Device::cmd_dispatch_indirect;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_dispatch_indirect(
				&fixture.device,
				Default::default(),
				Default::default(),
				Default::default()
			),
			Err(CallError::MissingCommand("vkCmdDispatchIndirect"))
		));
		assert!(matches!(
			fixture.device.cmd_dispatch_indirect(
				Default::default(),
				Default::default(),
				Default::default()
			),
			Err(CallError::MissingCommand("vkCmdDispatchIndirect"))
		));
	}
}

#[test]
fn cmd_subpass_shading_huawei_signature_and_missing_command() {
	type Signature = unsafe fn(&vk::Device, vk::CommandBuffer) -> Result<(), CallError>;
	let _: Signature = vk::cmd_subpass_shading_huawei;
	let _: Signature = vk::Device::cmd_subpass_shading_huawei;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_subpass_shading_huawei(&fixture.device, std::mem::zeroed::<vk::CommandBuffer>()),
			Err(CallError::MissingCommand("vkCmdSubpassShadingHUAWEI"))
		));
		assert!(matches!(
			fixture
				.device
				.cmd_subpass_shading_huawei(std::mem::zeroed::<vk::CommandBuffer>()),
			Err(CallError::MissingCommand("vkCmdSubpassShadingHUAWEI"))
		));
	}
}

#[test]
fn cmd_subpass_shading_huawei_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::CommandBuffer) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(MATCHED.get() && (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)));
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdSubpassShadingHUAWEI = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdSubpassShadingHUAWEI, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdSubpassShadingHUAWEI", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_subpass_shading_huawei(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
		)
		.unwrap();
		vk::Device::cmd_subpass_shading_huawei(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_draw_cluster_huawei_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, vk::CommandBuffer, u32, u32, u32) -> Result<(), CallError>;
	let _: Signature = vk::cmd_draw_cluster_huawei;
	let _: Signature = vk::Device::cmd_draw_cluster_huawei;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_draw_cluster_huawei(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>()
			),
			Err(CallError::MissingCommand("vkCmdDrawClusterHUAWEI"))
		));
		assert!(matches!(
			fixture.device.cmd_draw_cluster_huawei(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>()
			),
			Err(CallError::MissingCommand("vkCmdDrawClusterHUAWEI"))
		));
	}
}

#[test]
fn cmd_draw_cluster_huawei_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::CommandBuffer, arg_1: u32, arg_2: u32, arg_3: u32) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == Default::default()
					&& arg_2 == Default::default()
					&& arg_3 == Default::default()),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdDrawClusterHUAWEI = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdDrawClusterHUAWEI, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdDrawClusterHUAWEI", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_draw_cluster_huawei(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
			Default::default(),
			Default::default(),
		)
		.unwrap();
		vk::Device::cmd_draw_cluster_huawei(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
			Default::default(),
			Default::default(),
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_draw_cluster_indirect_huawei_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, vk::CommandBuffer, vk::Buffer, vk::DeviceSize) -> Result<(), CallError>;
	let _: Signature = vk::cmd_draw_cluster_indirect_huawei;
	let _: Signature = vk::Device::cmd_draw_cluster_indirect_huawei;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_draw_cluster_indirect_huawei(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::Buffer>(),
				std::mem::zeroed::<vk::DeviceSize>()
			),
			Err(CallError::MissingCommand("vkCmdDrawClusterIndirectHUAWEI"))
		));
		assert!(matches!(
			fixture.device.cmd_draw_cluster_indirect_huawei(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::Buffer>(),
				std::mem::zeroed::<vk::DeviceSize>()
			),
			Err(CallError::MissingCommand("vkCmdDrawClusterIndirectHUAWEI"))
		));
	}
}

#[test]
fn cmd_draw_cluster_indirect_huawei_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: vk::Buffer,
		arg_2: vk::DeviceSize,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == vk::Buffer::from_raw(305398016_u64 as _)
					&& arg_2 == 305398272_u64 as vk::DeviceSize),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdDrawClusterIndirectHUAWEI = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdDrawClusterIndirectHUAWEI, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdDrawClusterIndirectHUAWEI", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_draw_cluster_indirect_huawei(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::Buffer::from_raw(305398016_u64 as _),
			305398272_u64 as vk::DeviceSize,
		)
		.unwrap();
		vk::Device::cmd_draw_cluster_indirect_huawei(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::Buffer::from_raw(305398016_u64 as _),
			305398272_u64 as vk::DeviceSize,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_update_pipeline_indirect_buffer_nv_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		vk::PipelineBindPoint,
		vk::Pipeline,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_update_pipeline_indirect_buffer_nv;
	let _: Signature = vk::Device::cmd_update_pipeline_indirect_buffer_nv;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_update_pipeline_indirect_buffer_nv(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::PipelineBindPoint>(),
				std::mem::zeroed::<vk::Pipeline>()
			),
			Err(CallError::MissingCommand(
				"vkCmdUpdatePipelineIndirectBufferNV"
			))
		));
		assert!(matches!(
			fixture.device.cmd_update_pipeline_indirect_buffer_nv(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::PipelineBindPoint>(),
				std::mem::zeroed::<vk::Pipeline>()
			),
			Err(CallError::MissingCommand(
				"vkCmdUpdatePipelineIndirectBufferNV"
			))
		));
	}
}

#[test]
fn cmd_update_pipeline_indirect_buffer_nv_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: vk::PipelineBindPoint,
		arg_2: vk::Pipeline,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == vk::PipelineBindPoint::from_raw(305398016_u64 as _)
					&& arg_2 == vk::Pipeline::from_raw(305398272_u64 as _)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdUpdatePipelineIndirectBufferNV = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkCmdUpdatePipelineIndirectBufferNV,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdUpdatePipelineIndirectBufferNV", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_update_pipeline_indirect_buffer_nv(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::PipelineBindPoint::from_raw(305398016_u64 as _),
			vk::Pipeline::from_raw(305398272_u64 as _),
		)
		.unwrap();
		vk::Device::cmd_update_pipeline_indirect_buffer_nv(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::PipelineBindPoint::from_raw(305398016_u64 as _),
			vk::Pipeline::from_raw(305398272_u64 as _),
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_copy_buffer_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		vk::Buffer,
		vk::Buffer,
		&[vk::BufferCopy],
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_copy_buffer;
	let _: Signature = vk::Device::cmd_copy_buffer;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_copy_buffer(
				&fixture.device,
				Default::default(),
				Default::default(),
				Default::default(),
				&[]
			),
			Err(CallError::MissingCommand("vkCmdCopyBuffer"))
		));
		assert!(matches!(
			fixture.device.cmd_copy_buffer(
				Default::default(),
				Default::default(),
				Default::default(),
				&[]
			),
			Err(CallError::MissingCommand("vkCmdCopyBuffer"))
		));
	}
}

#[test]
fn cmd_copy_image_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		vk::Image,
		vk::ImageLayout,
		vk::Image,
		vk::ImageLayout,
		&[vk::ImageCopy],
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_copy_image;
	let _: Signature = vk::Device::cmd_copy_image;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_copy_image(
				&fixture.device,
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default(),
				&[]
			),
			Err(CallError::MissingCommand("vkCmdCopyImage"))
		));
		assert!(matches!(
			fixture.device.cmd_copy_image(
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default(),
				&[]
			),
			Err(CallError::MissingCommand("vkCmdCopyImage"))
		));
	}
}

#[test]
fn cmd_blit_image_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		vk::Image,
		vk::ImageLayout,
		vk::Image,
		vk::ImageLayout,
		&[vk::ImageBlit],
		vk::Filter,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_blit_image;
	let _: Signature = vk::Device::cmd_blit_image;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_blit_image(
				&fixture.device,
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default(),
				&[],
				Default::default()
			),
			Err(CallError::MissingCommand("vkCmdBlitImage"))
		));
		assert!(matches!(
			fixture.device.cmd_blit_image(
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default(),
				&[],
				Default::default()
			),
			Err(CallError::MissingCommand("vkCmdBlitImage"))
		));
	}
}

#[test]
fn cmd_copy_buffer_to_image_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		vk::Buffer,
		vk::Image,
		vk::ImageLayout,
		&[vk::BufferImageCopy],
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_copy_buffer_to_image;
	let _: Signature = vk::Device::cmd_copy_buffer_to_image;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_copy_buffer_to_image(
				&fixture.device,
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default(),
				&[]
			),
			Err(CallError::MissingCommand("vkCmdCopyBufferToImage"))
		));
		assert!(matches!(
			fixture.device.cmd_copy_buffer_to_image(
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default(),
				&[]
			),
			Err(CallError::MissingCommand("vkCmdCopyBufferToImage"))
		));
	}
}

#[test]
fn cmd_copy_image_to_buffer_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		vk::Image,
		vk::ImageLayout,
		vk::Buffer,
		&[vk::BufferImageCopy],
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_copy_image_to_buffer;
	let _: Signature = vk::Device::cmd_copy_image_to_buffer;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_copy_image_to_buffer(
				&fixture.device,
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default(),
				&[]
			),
			Err(CallError::MissingCommand("vkCmdCopyImageToBuffer"))
		));
		assert!(matches!(
			fixture.device.cmd_copy_image_to_buffer(
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default(),
				&[]
			),
			Err(CallError::MissingCommand("vkCmdCopyImageToBuffer"))
		));
	}
}

#[test]
fn cmd_copy_memory_indirect_nv_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, vk::CommandBuffer, vk::DeviceAddress, u32, u32) -> Result<(), CallError>;
	let _: Signature = vk::cmd_copy_memory_indirect_nv;
	let _: Signature = vk::Device::cmd_copy_memory_indirect_nv;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_copy_memory_indirect_nv(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::DeviceAddress>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>()
			),
			Err(CallError::MissingCommand("vkCmdCopyMemoryIndirectNV"))
		));
		assert!(matches!(
			fixture.device.cmd_copy_memory_indirect_nv(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::DeviceAddress>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>()
			),
			Err(CallError::MissingCommand("vkCmdCopyMemoryIndirectNV"))
		));
	}
}

#[test]
fn cmd_copy_memory_indirect_nv_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: vk::DeviceAddress,
		arg_2: u32,
		arg_3: u32,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == 305398016_u64 as vk::DeviceAddress
					&& arg_2 == Default::default()
					&& arg_3 == Default::default()),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdCopyMemoryIndirectNV = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdCopyMemoryIndirectNV, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdCopyMemoryIndirectNV", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_copy_memory_indirect_nv(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			305398016_u64 as vk::DeviceAddress,
			Default::default(),
			Default::default(),
		)
		.unwrap();
		vk::Device::cmd_copy_memory_indirect_nv(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			305398016_u64 as vk::DeviceAddress,
			Default::default(),
			Default::default(),
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_copy_memory_indirect_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		*const vk::CopyMemoryIndirectInfoKHR<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_copy_memory_indirect_khr;
	let _: Signature = vk::Device::cmd_copy_memory_indirect_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_copy_memory_indirect_khr(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::CopyMemoryIndirectInfoKHR<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdCopyMemoryIndirectKHR"))
		));
		assert!(matches!(
			fixture.device.cmd_copy_memory_indirect_khr(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::CopyMemoryIndirectInfoKHR<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdCopyMemoryIndirectKHR"))
		));
	}
}

#[test]
fn cmd_copy_memory_indirect_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: *const vk::CopyMemoryIndirectInfoKHR<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::CopyMemoryIndirectInfoKHR<'_>,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdCopyMemoryIndirectKHR = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdCopyMemoryIndirectKHR, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdCopyMemoryIndirectKHR", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_copy_memory_indirect_khr(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::CopyMemoryIndirectInfoKHR<'_>,
		)
		.unwrap();
		vk::Device::cmd_copy_memory_indirect_khr(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::CopyMemoryIndirectInfoKHR<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_copy_memory_to_image_indirect_nv_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		vk::DeviceAddress,
		u32,
		u32,
		vk::Image,
		vk::ImageLayout,
		*const vk::ImageSubresourceLayers,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_copy_memory_to_image_indirect_nv;
	let _: Signature = vk::Device::cmd_copy_memory_to_image_indirect_nv;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_copy_memory_to_image_indirect_nv(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::DeviceAddress>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<vk::Image>(),
				std::mem::zeroed::<vk::ImageLayout>(),
				std::mem::zeroed::<*const vk::ImageSubresourceLayers>()
			),
			Err(CallError::MissingCommand(
				"vkCmdCopyMemoryToImageIndirectNV"
			))
		));
		assert!(matches!(
			fixture.device.cmd_copy_memory_to_image_indirect_nv(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::DeviceAddress>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<vk::Image>(),
				std::mem::zeroed::<vk::ImageLayout>(),
				std::mem::zeroed::<*const vk::ImageSubresourceLayers>()
			),
			Err(CallError::MissingCommand(
				"vkCmdCopyMemoryToImageIndirectNV"
			))
		));
	}
}

#[test]
fn cmd_copy_memory_to_image_indirect_nv_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: vk::DeviceAddress,
		arg_2: u32,
		arg_3: u32,
		arg_4: vk::Image,
		arg_5: vk::ImageLayout,
		arg_6: *const vk::ImageSubresourceLayers,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == 305398016_u64 as vk::DeviceAddress
					&& arg_2 == Default::default()
					&& arg_3 == Default::default()
					&& arg_4 == vk::Image::from_raw(305398784_u64 as _)
					&& arg_5 == vk::ImageLayout::from_raw(305399040_u64 as _)
					&& std::ptr::eq(
						arg_6,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305399296)
							as *const vk::ImageSubresourceLayers,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdCopyMemoryToImageIndirectNV = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkCmdCopyMemoryToImageIndirectNV,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdCopyMemoryToImageIndirectNV", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_copy_memory_to_image_indirect_nv(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			305398016_u64 as vk::DeviceAddress,
			Default::default(),
			Default::default(),
			vk::Image::from_raw(305398784_u64 as _),
			vk::ImageLayout::from_raw(305399040_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305399296)
				as *const vk::ImageSubresourceLayers,
		)
		.unwrap();
		vk::Device::cmd_copy_memory_to_image_indirect_nv(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			305398016_u64 as vk::DeviceAddress,
			Default::default(),
			Default::default(),
			vk::Image::from_raw(305398784_u64 as _),
			vk::ImageLayout::from_raw(305399040_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305399296)
				as *const vk::ImageSubresourceLayers,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_copy_memory_to_image_indirect_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		*const vk::CopyMemoryToImageIndirectInfoKHR<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_copy_memory_to_image_indirect_khr;
	let _: Signature = vk::Device::cmd_copy_memory_to_image_indirect_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_copy_memory_to_image_indirect_khr(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::CopyMemoryToImageIndirectInfoKHR<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkCmdCopyMemoryToImageIndirectKHR"
			))
		));
		assert!(matches!(
			fixture.device.cmd_copy_memory_to_image_indirect_khr(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::CopyMemoryToImageIndirectInfoKHR<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkCmdCopyMemoryToImageIndirectKHR"
			))
		));
	}
}

#[test]
fn cmd_copy_memory_to_image_indirect_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: *const vk::CopyMemoryToImageIndirectInfoKHR<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::CopyMemoryToImageIndirectInfoKHR<'_>,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdCopyMemoryToImageIndirectKHR = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkCmdCopyMemoryToImageIndirectKHR,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdCopyMemoryToImageIndirectKHR", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_copy_memory_to_image_indirect_khr(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::CopyMemoryToImageIndirectInfoKHR<'_>,
		)
		.unwrap();
		vk::Device::cmd_copy_memory_to_image_indirect_khr(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::CopyMemoryToImageIndirectInfoKHR<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_update_buffer_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		vk::Buffer,
		vk::DeviceSize,
		&[u8],
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_update_buffer;
	let _: Signature = vk::Device::cmd_update_buffer;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_update_buffer(
				&fixture.device,
				Default::default(),
				Default::default(),
				Default::default(),
				&[]
			),
			Err(CallError::MissingCommand("vkCmdUpdateBuffer"))
		));
		assert!(matches!(
			fixture.device.cmd_update_buffer(
				Default::default(),
				Default::default(),
				Default::default(),
				&[]
			),
			Err(CallError::MissingCommand("vkCmdUpdateBuffer"))
		));
	}
}

#[test]
fn cmd_clear_color_image_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		vk::Image,
		vk::ImageLayout,
		&vk::ClearColorValue,
		&[vk::ImageSubresourceRange],
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_clear_color_image;
	let _: Signature = vk::Device::cmd_clear_color_image;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_clear_color_image(
				&fixture.device,
				Default::default(),
				Default::default(),
				Default::default(),
				&std::mem::zeroed::<vk::ClearColorValue>(),
				&[]
			),
			Err(CallError::MissingCommand("vkCmdClearColorImage"))
		));
		assert!(matches!(
			fixture.device.cmd_clear_color_image(
				Default::default(),
				Default::default(),
				Default::default(),
				&std::mem::zeroed::<vk::ClearColorValue>(),
				&[]
			),
			Err(CallError::MissingCommand("vkCmdClearColorImage"))
		));
	}
}

#[test]
fn cmd_clear_depth_stencil_image_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		vk::Image,
		vk::ImageLayout,
		&vk::ClearDepthStencilValue,
		&[vk::ImageSubresourceRange],
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_clear_depth_stencil_image;
	let _: Signature = vk::Device::cmd_clear_depth_stencil_image;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_clear_depth_stencil_image(
				&fixture.device,
				Default::default(),
				Default::default(),
				Default::default(),
				&std::mem::zeroed::<vk::ClearDepthStencilValue>(),
				&[]
			),
			Err(CallError::MissingCommand("vkCmdClearDepthStencilImage"))
		));
		assert!(matches!(
			fixture.device.cmd_clear_depth_stencil_image(
				Default::default(),
				Default::default(),
				Default::default(),
				&std::mem::zeroed::<vk::ClearDepthStencilValue>(),
				&[]
			),
			Err(CallError::MissingCommand("vkCmdClearDepthStencilImage"))
		));
	}
}

#[test]
fn cmd_clear_attachments_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		&[vk::ClearAttachment],
		&[vk::ClearRect],
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_clear_attachments;
	let _: Signature = vk::Device::cmd_clear_attachments;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_clear_attachments(&fixture.device, Default::default(), &[], &[]),
			Err(CallError::MissingCommand("vkCmdClearAttachments"))
		));
		assert!(matches!(
			fixture
				.device
				.cmd_clear_attachments(Default::default(), &[], &[]),
			Err(CallError::MissingCommand("vkCmdClearAttachments"))
		));
	}
}

#[test]
fn cmd_resolve_image_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		vk::Image,
		vk::ImageLayout,
		vk::Image,
		vk::ImageLayout,
		&[vk::ImageResolve],
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_resolve_image;
	let _: Signature = vk::Device::cmd_resolve_image;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_resolve_image(
				&fixture.device,
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default(),
				&[]
			),
			Err(CallError::MissingCommand("vkCmdResolveImage"))
		));
		assert!(matches!(
			fixture.device.cmd_resolve_image(
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default(),
				&[]
			),
			Err(CallError::MissingCommand("vkCmdResolveImage"))
		));
	}
}

#[test]
fn cmd_set_event_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		vk::Event,
		vk::PipelineStageFlags,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_event;
	let _: Signature = vk::Device::cmd_set_event;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_event(
				&fixture.device,
				Default::default(),
				Default::default(),
				Default::default()
			),
			Err(CallError::MissingCommand("vkCmdSetEvent"))
		));
		assert!(matches!(
			fixture
				.device
				.cmd_set_event(Default::default(), Default::default(), Default::default()),
			Err(CallError::MissingCommand("vkCmdSetEvent"))
		));
	}
}

#[test]
fn cmd_reset_event_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		vk::Event,
		vk::PipelineStageFlags,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_reset_event;
	let _: Signature = vk::Device::cmd_reset_event;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_reset_event(
				&fixture.device,
				Default::default(),
				Default::default(),
				Default::default()
			),
			Err(CallError::MissingCommand("vkCmdResetEvent"))
		));
		assert!(matches!(
			fixture
				.device
				.cmd_reset_event(Default::default(), Default::default(), Default::default()),
			Err(CallError::MissingCommand("vkCmdResetEvent"))
		));
	}
}

#[test]
fn cmd_wait_events_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		&[vk::Event],
		vk::PipelineStageFlags,
		vk::PipelineStageFlags,
		&[vk::MemoryBarrier<'_>],
		&[vk::BufferMemoryBarrier<'_>],
		&[vk::ImageMemoryBarrier<'_>],
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_wait_events;
	let _: Signature = vk::Device::cmd_wait_events;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_wait_events(
				&fixture.device,
				Default::default(),
				&[],
				Default::default(),
				Default::default(),
				&[],
				&[],
				&[]
			),
			Err(CallError::MissingCommand("vkCmdWaitEvents"))
		));
		assert!(matches!(
			fixture.device.cmd_wait_events(
				Default::default(),
				&[],
				Default::default(),
				Default::default(),
				&[],
				&[],
				&[]
			),
			Err(CallError::MissingCommand("vkCmdWaitEvents"))
		));
	}
}

#[test]
fn cmd_pipeline_barrier_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		vk::PipelineStageFlags,
		vk::PipelineStageFlags,
		vk::DependencyFlags,
		&[vk::MemoryBarrier<'_>],
		&[vk::BufferMemoryBarrier<'_>],
		&[vk::ImageMemoryBarrier<'_>],
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_pipeline_barrier;
	let _: Signature = vk::Device::cmd_pipeline_barrier;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_pipeline_barrier(
				&fixture.device,
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default(),
				&[],
				&[],
				&[]
			),
			Err(CallError::MissingCommand("vkCmdPipelineBarrier"))
		));
		assert!(matches!(
			fixture.device.cmd_pipeline_barrier(
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default(),
				&[],
				&[],
				&[]
			),
			Err(CallError::MissingCommand("vkCmdPipelineBarrier"))
		));
	}
}

#[test]
fn cmd_begin_query_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		vk::QueryPool,
		u32,
		vk::QueryControlFlags,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_begin_query;
	let _: Signature = vk::Device::cmd_begin_query;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_begin_query(
				&fixture.device,
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default()
			),
			Err(CallError::MissingCommand("vkCmdBeginQuery"))
		));
		assert!(matches!(
			fixture.device.cmd_begin_query(
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default()
			),
			Err(CallError::MissingCommand("vkCmdBeginQuery"))
		));
	}
}

#[test]
fn cmd_end_query_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, vk::CommandBuffer, vk::QueryPool, u32) -> Result<(), CallError>;
	let _: Signature = vk::cmd_end_query;
	let _: Signature = vk::Device::cmd_end_query;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_end_query(
				&fixture.device,
				Default::default(),
				Default::default(),
				Default::default()
			),
			Err(CallError::MissingCommand("vkCmdEndQuery"))
		));
		assert!(matches!(
			fixture
				.device
				.cmd_end_query(Default::default(), Default::default(), Default::default()),
			Err(CallError::MissingCommand("vkCmdEndQuery"))
		));
	}
}

#[test]
fn cmd_begin_conditional_rendering_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		*const vk::ConditionalRenderingBeginInfoEXT<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_begin_conditional_rendering_ext;
	let _: Signature = vk::Device::cmd_begin_conditional_rendering_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_begin_conditional_rendering_ext(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::ConditionalRenderingBeginInfoEXT<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkCmdBeginConditionalRenderingEXT"
			))
		));
		assert!(matches!(
			fixture.device.cmd_begin_conditional_rendering_ext(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::ConditionalRenderingBeginInfoEXT<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkCmdBeginConditionalRenderingEXT"
			))
		));
	}
}

#[test]
fn cmd_begin_conditional_rendering_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: *const vk::ConditionalRenderingBeginInfoEXT<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::ConditionalRenderingBeginInfoEXT<'_>,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdBeginConditionalRenderingEXT = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkCmdBeginConditionalRenderingEXT,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdBeginConditionalRenderingEXT", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_begin_conditional_rendering_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::ConditionalRenderingBeginInfoEXT<'_>,
		)
		.unwrap();
		vk::Device::cmd_begin_conditional_rendering_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::ConditionalRenderingBeginInfoEXT<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_end_conditional_rendering_ext_signature_and_missing_command() {
	type Signature = unsafe fn(&vk::Device, vk::CommandBuffer) -> Result<(), CallError>;
	let _: Signature = vk::cmd_end_conditional_rendering_ext;
	let _: Signature = vk::Device::cmd_end_conditional_rendering_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_end_conditional_rendering_ext(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>()
			),
			Err(CallError::MissingCommand("vkCmdEndConditionalRenderingEXT"))
		));
		assert!(matches!(
			fixture
				.device
				.cmd_end_conditional_rendering_ext(std::mem::zeroed::<vk::CommandBuffer>()),
			Err(CallError::MissingCommand("vkCmdEndConditionalRenderingEXT"))
		));
	}
}

#[test]
fn cmd_end_conditional_rendering_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::CommandBuffer) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(MATCHED.get() && (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)));
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdEndConditionalRenderingEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdEndConditionalRenderingEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdEndConditionalRenderingEXT", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_end_conditional_rendering_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
		)
		.unwrap();
		vk::Device::cmd_end_conditional_rendering_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_begin_custom_resolve_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		*const vk::BeginCustomResolveInfoEXT<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_begin_custom_resolve_ext;
	let _: Signature = vk::Device::cmd_begin_custom_resolve_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_begin_custom_resolve_ext(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::BeginCustomResolveInfoEXT<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdBeginCustomResolveEXT"))
		));
		assert!(matches!(
			fixture.device.cmd_begin_custom_resolve_ext(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::BeginCustomResolveInfoEXT<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdBeginCustomResolveEXT"))
		));
	}
}

#[test]
fn cmd_begin_custom_resolve_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: *const vk::BeginCustomResolveInfoEXT<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::BeginCustomResolveInfoEXT<'_>,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdBeginCustomResolveEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdBeginCustomResolveEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdBeginCustomResolveEXT", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_begin_custom_resolve_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::BeginCustomResolveInfoEXT<'_>,
		)
		.unwrap();
		vk::Device::cmd_begin_custom_resolve_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::BeginCustomResolveInfoEXT<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_reset_query_pool_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, vk::CommandBuffer, vk::QueryPool, u32, u32) -> Result<(), CallError>;
	let _: Signature = vk::cmd_reset_query_pool;
	let _: Signature = vk::Device::cmd_reset_query_pool;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_reset_query_pool(
				&fixture.device,
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default()
			),
			Err(CallError::MissingCommand("vkCmdResetQueryPool"))
		));
		assert!(matches!(
			fixture.device.cmd_reset_query_pool(
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default()
			),
			Err(CallError::MissingCommand("vkCmdResetQueryPool"))
		));
	}
}

#[test]
fn cmd_write_timestamp_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		vk::PipelineStageFlagBits,
		vk::QueryPool,
		u32,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_write_timestamp;
	let _: Signature = vk::Device::cmd_write_timestamp;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_write_timestamp(
				&fixture.device,
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default()
			),
			Err(CallError::MissingCommand("vkCmdWriteTimestamp"))
		));
		assert!(matches!(
			fixture.device.cmd_write_timestamp(
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default()
			),
			Err(CallError::MissingCommand("vkCmdWriteTimestamp"))
		));
	}
}

#[test]
fn cmd_copy_query_pool_results_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		vk::QueryPool,
		u32,
		u32,
		vk::Buffer,
		vk::DeviceSize,
		vk::DeviceSize,
		vk::QueryResultFlags,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_copy_query_pool_results;
	let _: Signature = vk::Device::cmd_copy_query_pool_results;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_copy_query_pool_results(
				&fixture.device,
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default()
			),
			Err(CallError::MissingCommand("vkCmdCopyQueryPoolResults"))
		));
		assert!(matches!(
			fixture.device.cmd_copy_query_pool_results(
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default()
			),
			Err(CallError::MissingCommand("vkCmdCopyQueryPoolResults"))
		));
	}
}

#[test]
fn cmd_push_constants_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		vk::PipelineLayout,
		vk::ShaderStageFlags,
		u32,
		&[u8],
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_push_constants;
	let _: Signature = vk::Device::cmd_push_constants;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_push_constants(
				&fixture.device,
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default(),
				&[]
			),
			Err(CallError::MissingCommand("vkCmdPushConstants"))
		));
		assert!(matches!(
			fixture.device.cmd_push_constants(
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default(),
				&[]
			),
			Err(CallError::MissingCommand("vkCmdPushConstants"))
		));
	}
}

#[test]
fn cmd_begin_render_pass_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		&vk::RenderPassBeginInfo<'_>,
		vk::SubpassContents,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_begin_render_pass;
	let _: Signature = vk::Device::cmd_begin_render_pass;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_begin_render_pass(
				&fixture.device,
				Default::default(),
				&std::mem::zeroed::<vk::RenderPassBeginInfo<'_>>(),
				Default::default()
			),
			Err(CallError::MissingCommand("vkCmdBeginRenderPass"))
		));
		assert!(matches!(
			fixture.device.cmd_begin_render_pass(
				Default::default(),
				&std::mem::zeroed::<vk::RenderPassBeginInfo<'_>>(),
				Default::default()
			),
			Err(CallError::MissingCommand("vkCmdBeginRenderPass"))
		));
	}
}

#[test]
fn cmd_next_subpass_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, vk::CommandBuffer, vk::SubpassContents) -> Result<(), CallError>;
	let _: Signature = vk::cmd_next_subpass;
	let _: Signature = vk::Device::cmd_next_subpass;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_next_subpass(&fixture.device, Default::default(), Default::default()),
			Err(CallError::MissingCommand("vkCmdNextSubpass"))
		));
		assert!(matches!(
			fixture
				.device
				.cmd_next_subpass(Default::default(), Default::default()),
			Err(CallError::MissingCommand("vkCmdNextSubpass"))
		));
	}
}

#[test]
fn cmd_end_render_pass_signature_and_missing_command() {
	type Signature = unsafe fn(&vk::Device, vk::CommandBuffer) -> Result<(), CallError>;
	let _: Signature = vk::cmd_end_render_pass;
	let _: Signature = vk::Device::cmd_end_render_pass;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_end_render_pass(&fixture.device, Default::default()),
			Err(CallError::MissingCommand("vkCmdEndRenderPass"))
		));
		assert!(matches!(
			fixture.device.cmd_end_render_pass(Default::default()),
			Err(CallError::MissingCommand("vkCmdEndRenderPass"))
		));
	}
}

#[test]
fn cmd_execute_commands_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, vk::CommandBuffer, &[vk::CommandBuffer]) -> Result<(), CallError>;
	let _: Signature = vk::cmd_execute_commands;
	let _: Signature = vk::Device::cmd_execute_commands;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_execute_commands(&fixture.device, Default::default(), &[]),
			Err(CallError::MissingCommand("vkCmdExecuteCommands"))
		));
		assert!(matches!(
			fixture.device.cmd_execute_commands(Default::default(), &[]),
			Err(CallError::MissingCommand("vkCmdExecuteCommands"))
		));
	}
}

#[cfg(feature = "platform-android")]
#[test]
fn create_android_surface_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		*const vk::AndroidSurfaceCreateInfoKHR<'_>,
		*const vk::AllocationCallbacks,
		*mut vk::SurfaceKHR,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::create_android_surface_khr;
	let _: Signature = vk::Instance::create_android_surface_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::create_android_surface_khr(
				&fixture.instance,
				std::mem::zeroed::<*const vk::AndroidSurfaceCreateInfoKHR<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::SurfaceKHR>()
			),
			Err(CallError::MissingCommand("vkCreateAndroidSurfaceKHR"))
		));
		assert!(matches!(
			fixture.instance.create_android_surface_khr(
				std::mem::zeroed::<*const vk::AndroidSurfaceCreateInfoKHR<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::SurfaceKHR>()
			),
			Err(CallError::MissingCommand("vkCreateAndroidSurfaceKHR"))
		));
	}
}

#[cfg(feature = "platform-android")]
#[test]
fn create_android_surface_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::InstanceHandle,
		arg_1: *const vk::AndroidSurfaceCreateInfoKHR<'_>,
		arg_2: *const vk::AllocationCallbacks,
		arg_3: *mut vk::SurfaceKHR,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::InstanceHandle::from_raw(0x1000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::AndroidSurfaceCreateInfoKHR<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
				) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::SurfaceKHR,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCreateAndroidSurfaceKHR = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCreateAndroidSurfaceKHR, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCreateAndroidSurfaceKHR", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::create_android_surface_khr(
					&fixture.instance,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::AndroidSurfaceCreateInfoKHR<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::SurfaceKHR
				),
				expected
			);
			assert_eq!(
				vk::Instance::create_android_surface_khr(
					&fixture.instance,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::AndroidSurfaceCreateInfoKHR<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::SurfaceKHR
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[cfg(feature = "platform-ohos")]
#[test]
fn create_surface_ohos_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		*const vk::SurfaceCreateInfoOHOS<'_>,
		*const vk::AllocationCallbacks,
		*mut vk::SurfaceKHR,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::create_surface_ohos;
	let _: Signature = vk::Instance::create_surface_ohos;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::create_surface_ohos(
				&fixture.instance,
				std::mem::zeroed::<*const vk::SurfaceCreateInfoOHOS<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::SurfaceKHR>()
			),
			Err(CallError::MissingCommand("vkCreateSurfaceOHOS"))
		));
		assert!(matches!(
			fixture.instance.create_surface_ohos(
				std::mem::zeroed::<*const vk::SurfaceCreateInfoOHOS<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::SurfaceKHR>()
			),
			Err(CallError::MissingCommand("vkCreateSurfaceOHOS"))
		));
	}
}

#[cfg(feature = "platform-ohos")]
#[test]
fn create_surface_ohos_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::InstanceHandle,
		arg_1: *const vk::SurfaceCreateInfoOHOS<'_>,
		arg_2: *const vk::AllocationCallbacks,
		arg_3: *mut vk::SurfaceKHR,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::InstanceHandle::from_raw(0x1000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::SurfaceCreateInfoOHOS<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
				) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::SurfaceKHR,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCreateSurfaceOHOS = Some(mock);
		let erased = std::mem::transmute::<vk::PFN_vkCreateSurfaceOHOS, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCreateSurfaceOHOS", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::create_surface_ohos(
					&fixture.instance,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::SurfaceCreateInfoOHOS<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::SurfaceKHR
				),
				expected
			);
			assert_eq!(
				vk::Instance::create_surface_ohos(
					&fixture.instance,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::SurfaceCreateInfoOHOS<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::SurfaceKHR
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_physical_device_display_properties_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		vk::PhysicalDevice,
		*mut u32,
		*mut vk::DisplayPropertiesKHR<'_>,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_physical_device_display_properties_khr;
	let _: Signature = vk::Instance::get_physical_device_display_properties_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_physical_device_display_properties_khr(
				&fixture.instance,
				std::mem::zeroed::<vk::PhysicalDevice>(),
				std::mem::zeroed::<*mut u32>(),
				std::mem::zeroed::<*mut vk::DisplayPropertiesKHR<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceDisplayPropertiesKHR"
			))
		));
		assert!(matches!(
			fixture.instance.get_physical_device_display_properties_khr(
				std::mem::zeroed::<vk::PhysicalDevice>(),
				std::mem::zeroed::<*mut u32>(),
				std::mem::zeroed::<*mut vk::DisplayPropertiesKHR<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceDisplayPropertiesKHR"
			))
		));
	}
}

#[test]
fn get_physical_device_display_properties_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::PhysicalDevice,
		arg_1: *mut u32,
		arg_2: *mut vk::DisplayPropertiesKHR<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::PhysicalDevice::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016) as *mut u32,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::DisplayPropertiesKHR<'_>,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetPhysicalDeviceDisplayPropertiesKHR = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetPhysicalDeviceDisplayPropertiesKHR,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkGetPhysicalDeviceDisplayPropertiesKHR", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_physical_device_display_properties_khr(
					&fixture.instance,
					vk::PhysicalDevice::from_raw(305397760_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016) as *mut u32,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::DisplayPropertiesKHR<'_>
				),
				expected
			);
			assert_eq!(
				vk::Instance::get_physical_device_display_properties_khr(
					&fixture.instance,
					vk::PhysicalDevice::from_raw(305397760_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016) as *mut u32,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::DisplayPropertiesKHR<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_physical_device_display_plane_properties_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		vk::PhysicalDevice,
		*mut u32,
		*mut vk::DisplayPlanePropertiesKHR,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_physical_device_display_plane_properties_khr;
	let _: Signature = vk::Instance::get_physical_device_display_plane_properties_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_physical_device_display_plane_properties_khr(
				&fixture.instance,
				std::mem::zeroed::<vk::PhysicalDevice>(),
				std::mem::zeroed::<*mut u32>(),
				std::mem::zeroed::<*mut vk::DisplayPlanePropertiesKHR>()
			),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceDisplayPlanePropertiesKHR"
			))
		));
		assert!(matches!(
			fixture
				.instance
				.get_physical_device_display_plane_properties_khr(
					std::mem::zeroed::<vk::PhysicalDevice>(),
					std::mem::zeroed::<*mut u32>(),
					std::mem::zeroed::<*mut vk::DisplayPlanePropertiesKHR>()
				),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceDisplayPlanePropertiesKHR"
			))
		));
	}
}

#[test]
fn get_physical_device_display_plane_properties_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::PhysicalDevice,
		arg_1: *mut u32,
		arg_2: *mut vk::DisplayPlanePropertiesKHR,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::PhysicalDevice::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016) as *mut u32,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::DisplayPlanePropertiesKHR,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture =
			Fixture::new_with_command(c"vkGetPhysicalDeviceDisplayPlanePropertiesKHR", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_physical_device_display_plane_properties_khr(
					&fixture.instance,
					vk::PhysicalDevice::from_raw(305397760_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016) as *mut u32,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::DisplayPlanePropertiesKHR
				),
				expected
			);
			assert_eq!(
				vk::Instance::get_physical_device_display_plane_properties_khr(
					&fixture.instance,
					vk::PhysicalDevice::from_raw(305397760_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016) as *mut u32,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::DisplayPlanePropertiesKHR
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_display_plane_supported_displays_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		vk::PhysicalDevice,
		u32,
		*mut u32,
		*mut vk::DisplayKHR,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_display_plane_supported_displays_khr;
	let _: Signature = vk::Instance::get_display_plane_supported_displays_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_display_plane_supported_displays_khr(
				&fixture.instance,
				std::mem::zeroed::<vk::PhysicalDevice>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*mut u32>(),
				std::mem::zeroed::<*mut vk::DisplayKHR>()
			),
			Err(CallError::MissingCommand(
				"vkGetDisplayPlaneSupportedDisplaysKHR"
			))
		));
		assert!(matches!(
			fixture.instance.get_display_plane_supported_displays_khr(
				std::mem::zeroed::<vk::PhysicalDevice>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*mut u32>(),
				std::mem::zeroed::<*mut vk::DisplayKHR>()
			),
			Err(CallError::MissingCommand(
				"vkGetDisplayPlaneSupportedDisplaysKHR"
			))
		));
	}
}

#[test]
fn get_display_plane_supported_displays_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::PhysicalDevice,
		arg_1: u32,
		arg_2: *mut u32,
		arg_3: *mut vk::DisplayKHR,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::PhysicalDevice::from_raw(305397760_u64 as _)
					&& arg_1 == Default::default()
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut u32,
					) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::DisplayKHR,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetDisplayPlaneSupportedDisplaysKHR = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetDisplayPlaneSupportedDisplaysKHR,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkGetDisplayPlaneSupportedDisplaysKHR", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_display_plane_supported_displays_khr(
					&fixture.instance,
					vk::PhysicalDevice::from_raw(305397760_u64 as _),
					Default::default(),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut u32,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::DisplayKHR
				),
				expected
			);
			assert_eq!(
				vk::Instance::get_display_plane_supported_displays_khr(
					&fixture.instance,
					vk::PhysicalDevice::from_raw(305397760_u64 as _),
					Default::default(),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut u32,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::DisplayKHR
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_display_mode_properties_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		vk::PhysicalDevice,
		vk::DisplayKHR,
		*mut u32,
		*mut vk::DisplayModePropertiesKHR,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_display_mode_properties_khr;
	let _: Signature = vk::Instance::get_display_mode_properties_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_display_mode_properties_khr(
				&fixture.instance,
				std::mem::zeroed::<vk::PhysicalDevice>(),
				std::mem::zeroed::<vk::DisplayKHR>(),
				std::mem::zeroed::<*mut u32>(),
				std::mem::zeroed::<*mut vk::DisplayModePropertiesKHR>()
			),
			Err(CallError::MissingCommand("vkGetDisplayModePropertiesKHR"))
		));
		assert!(matches!(
			fixture.instance.get_display_mode_properties_khr(
				std::mem::zeroed::<vk::PhysicalDevice>(),
				std::mem::zeroed::<vk::DisplayKHR>(),
				std::mem::zeroed::<*mut u32>(),
				std::mem::zeroed::<*mut vk::DisplayModePropertiesKHR>()
			),
			Err(CallError::MissingCommand("vkGetDisplayModePropertiesKHR"))
		));
	}
}

#[test]
fn get_display_mode_properties_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::PhysicalDevice,
		arg_1: vk::DisplayKHR,
		arg_2: *mut u32,
		arg_3: *mut vk::DisplayModePropertiesKHR,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::PhysicalDevice::from_raw(305397760_u64 as _)
					&& arg_1 == vk::DisplayKHR::from_raw(305398016_u64 as _)
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut u32,
					) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::DisplayModePropertiesKHR,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetDisplayModePropertiesKHR = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkGetDisplayModePropertiesKHR, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkGetDisplayModePropertiesKHR", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_display_mode_properties_khr(
					&fixture.instance,
					vk::PhysicalDevice::from_raw(305397760_u64 as _),
					vk::DisplayKHR::from_raw(305398016_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut u32,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::DisplayModePropertiesKHR
				),
				expected
			);
			assert_eq!(
				vk::Instance::get_display_mode_properties_khr(
					&fixture.instance,
					vk::PhysicalDevice::from_raw(305397760_u64 as _),
					vk::DisplayKHR::from_raw(305398016_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut u32,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::DisplayModePropertiesKHR
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn create_display_mode_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		vk::PhysicalDevice,
		vk::DisplayKHR,
		*const vk::DisplayModeCreateInfoKHR<'_>,
		*const vk::AllocationCallbacks,
		*mut vk::DisplayModeKHR,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::create_display_mode_khr;
	let _: Signature = vk::Instance::create_display_mode_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::create_display_mode_khr(
				&fixture.instance,
				std::mem::zeroed::<vk::PhysicalDevice>(),
				std::mem::zeroed::<vk::DisplayKHR>(),
				std::mem::zeroed::<*const vk::DisplayModeCreateInfoKHR<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::DisplayModeKHR>()
			),
			Err(CallError::MissingCommand("vkCreateDisplayModeKHR"))
		));
		assert!(matches!(
			fixture.instance.create_display_mode_khr(
				std::mem::zeroed::<vk::PhysicalDevice>(),
				std::mem::zeroed::<vk::DisplayKHR>(),
				std::mem::zeroed::<*const vk::DisplayModeCreateInfoKHR<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::DisplayModeKHR>()
			),
			Err(CallError::MissingCommand("vkCreateDisplayModeKHR"))
		));
	}
}

#[test]
fn create_display_mode_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::PhysicalDevice,
		arg_1: vk::DisplayKHR,
		arg_2: *const vk::DisplayModeCreateInfoKHR<'_>,
		arg_3: *const vk::AllocationCallbacks,
		arg_4: *mut vk::DisplayModeKHR,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::PhysicalDevice::from_raw(305397760_u64 as _)
					&& arg_1 == vk::DisplayKHR::from_raw(305398016_u64 as _)
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *const vk::DisplayModeCreateInfoKHR<'_>,
					) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *const vk::AllocationCallbacks,
				) && std::ptr::eq(
					arg_4,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784)
						as *mut vk::DisplayModeKHR,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCreateDisplayModeKHR = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCreateDisplayModeKHR, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCreateDisplayModeKHR", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::create_display_mode_khr(
					&fixture.instance,
					vk::PhysicalDevice::from_raw(305397760_u64 as _),
					vk::DisplayKHR::from_raw(305398016_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::DisplayModeCreateInfoKHR<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784)
						as *mut vk::DisplayModeKHR
				),
				expected
			);
			assert_eq!(
				vk::Instance::create_display_mode_khr(
					&fixture.instance,
					vk::PhysicalDevice::from_raw(305397760_u64 as _),
					vk::DisplayKHR::from_raw(305398016_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::DisplayModeCreateInfoKHR<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784)
						as *mut vk::DisplayModeKHR
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_display_plane_capabilities_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		vk::PhysicalDevice,
		vk::DisplayModeKHR,
		u32,
		*mut vk::DisplayPlaneCapabilitiesKHR,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_display_plane_capabilities_khr;
	let _: Signature = vk::Instance::get_display_plane_capabilities_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_display_plane_capabilities_khr(
				&fixture.instance,
				std::mem::zeroed::<vk::PhysicalDevice>(),
				std::mem::zeroed::<vk::DisplayModeKHR>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*mut vk::DisplayPlaneCapabilitiesKHR>()
			),
			Err(CallError::MissingCommand(
				"vkGetDisplayPlaneCapabilitiesKHR"
			))
		));
		assert!(matches!(
			fixture.instance.get_display_plane_capabilities_khr(
				std::mem::zeroed::<vk::PhysicalDevice>(),
				std::mem::zeroed::<vk::DisplayModeKHR>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*mut vk::DisplayPlaneCapabilitiesKHR>()
			),
			Err(CallError::MissingCommand(
				"vkGetDisplayPlaneCapabilitiesKHR"
			))
		));
	}
}

#[test]
fn get_display_plane_capabilities_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::PhysicalDevice,
		arg_1: vk::DisplayModeKHR,
		arg_2: u32,
		arg_3: *mut vk::DisplayPlaneCapabilitiesKHR,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::PhysicalDevice::from_raw(305397760_u64 as _)
					&& arg_1 == vk::DisplayModeKHR::from_raw(305398016_u64 as _)
					&& arg_2 == Default::default()
					&& std::ptr::eq(
						arg_3,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
							as *mut vk::DisplayPlaneCapabilitiesKHR,
					)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetDisplayPlaneCapabilitiesKHR = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetDisplayPlaneCapabilitiesKHR,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkGetDisplayPlaneCapabilitiesKHR", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_display_plane_capabilities_khr(
					&fixture.instance,
					vk::PhysicalDevice::from_raw(305397760_u64 as _),
					vk::DisplayModeKHR::from_raw(305398016_u64 as _),
					Default::default(),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::DisplayPlaneCapabilitiesKHR
				),
				expected
			);
			assert_eq!(
				vk::Instance::get_display_plane_capabilities_khr(
					&fixture.instance,
					vk::PhysicalDevice::from_raw(305397760_u64 as _),
					vk::DisplayModeKHR::from_raw(305398016_u64 as _),
					Default::default(),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::DisplayPlaneCapabilitiesKHR
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn create_display_plane_surface_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		*const vk::DisplaySurfaceCreateInfoKHR<'_>,
		*const vk::AllocationCallbacks,
		*mut vk::SurfaceKHR,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::create_display_plane_surface_khr;
	let _: Signature = vk::Instance::create_display_plane_surface_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::create_display_plane_surface_khr(
				&fixture.instance,
				std::mem::zeroed::<*const vk::DisplaySurfaceCreateInfoKHR<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::SurfaceKHR>()
			),
			Err(CallError::MissingCommand("vkCreateDisplayPlaneSurfaceKHR"))
		));
		assert!(matches!(
			fixture.instance.create_display_plane_surface_khr(
				std::mem::zeroed::<*const vk::DisplaySurfaceCreateInfoKHR<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::SurfaceKHR>()
			),
			Err(CallError::MissingCommand("vkCreateDisplayPlaneSurfaceKHR"))
		));
	}
}

#[test]
fn create_display_plane_surface_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::InstanceHandle,
		arg_1: *const vk::DisplaySurfaceCreateInfoKHR<'_>,
		arg_2: *const vk::AllocationCallbacks,
		arg_3: *mut vk::SurfaceKHR,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::InstanceHandle::from_raw(0x1000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::DisplaySurfaceCreateInfoKHR<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
				) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::SurfaceKHR,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCreateDisplayPlaneSurfaceKHR = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCreateDisplayPlaneSurfaceKHR, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCreateDisplayPlaneSurfaceKHR", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::create_display_plane_surface_khr(
					&fixture.instance,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::DisplaySurfaceCreateInfoKHR<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::SurfaceKHR
				),
				expected
			);
			assert_eq!(
				vk::Instance::create_display_plane_surface_khr(
					&fixture.instance,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::DisplaySurfaceCreateInfoKHR<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::SurfaceKHR
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn create_shared_swapchains_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		u32,
		*const vk::SwapchainCreateInfoKHR<'_>,
		*const vk::AllocationCallbacks,
		*mut vk::SwapchainKHR,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::create_shared_swapchains_khr;
	let _: Signature = vk::Device::create_shared_swapchains_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::create_shared_swapchains_khr(
				&fixture.device,
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::SwapchainCreateInfoKHR<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::SwapchainKHR>()
			),
			Err(CallError::MissingCommand("vkCreateSharedSwapchainsKHR"))
		));
		assert!(matches!(
			fixture.device.create_shared_swapchains_khr(
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::SwapchainCreateInfoKHR<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::SwapchainKHR>()
			),
			Err(CallError::MissingCommand("vkCreateSharedSwapchainsKHR"))
		));
	}
}

#[test]
fn create_shared_swapchains_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: u32,
		arg_2: *const vk::SwapchainCreateInfoKHR<'_>,
		arg_3: *const vk::AllocationCallbacks,
		arg_4: *mut vk::SwapchainKHR,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == Default::default()
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *const vk::SwapchainCreateInfoKHR<'_>,
					) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *const vk::AllocationCallbacks,
				) && std::ptr::eq(
					arg_4,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784) as *mut vk::SwapchainKHR,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCreateSharedSwapchainsKHR = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCreateSharedSwapchainsKHR, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCreateSharedSwapchainsKHR", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::create_shared_swapchains_khr(
					&fixture.device,
					Default::default(),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::SwapchainCreateInfoKHR<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784) as *mut vk::SwapchainKHR
				),
				expected
			);
			assert_eq!(
				vk::Device::create_shared_swapchains_khr(
					&fixture.device,
					Default::default(),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::SwapchainCreateInfoKHR<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784) as *mut vk::SwapchainKHR
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn destroy_surface_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		vk::SurfaceKHR,
		*const vk::AllocationCallbacks,
	) -> Result<(), CallError>;
	let _: Signature = vk::destroy_surface_khr;
	let _: Signature = vk::Instance::destroy_surface_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::destroy_surface_khr(
				&fixture.instance,
				std::mem::zeroed::<vk::SurfaceKHR>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>()
			),
			Err(CallError::MissingCommand("vkDestroySurfaceKHR"))
		));
		assert!(matches!(
			fixture.instance.destroy_surface_khr(
				std::mem::zeroed::<vk::SurfaceKHR>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>()
			),
			Err(CallError::MissingCommand("vkDestroySurfaceKHR"))
		));
	}
}

#[test]
fn destroy_surface_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::InstanceHandle,
		arg_1: vk::SurfaceKHR,
		arg_2: *const vk::AllocationCallbacks,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::InstanceHandle::from_raw(0x1000)
					&& arg_1 == vk::SurfaceKHR::from_raw(305398016_u64 as _)
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *const vk::AllocationCallbacks,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkDestroySurfaceKHR = Some(mock);
		let erased = std::mem::transmute::<vk::PFN_vkDestroySurfaceKHR, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkDestroySurfaceKHR", erased);
		let resolutions = Fixture::query_count();
		vk::destroy_surface_khr(
			&fixture.instance,
			vk::SurfaceKHR::from_raw(305398016_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::AllocationCallbacks,
		)
		.unwrap();
		vk::Instance::destroy_surface_khr(
			&fixture.instance,
			vk::SurfaceKHR::from_raw(305398016_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::AllocationCallbacks,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_physical_device_surface_support_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		vk::PhysicalDevice,
		u32,
		vk::SurfaceKHR,
		*mut vk::Bool32,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_physical_device_surface_support_khr;
	let _: Signature = vk::Instance::get_physical_device_surface_support_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_physical_device_surface_support_khr(
				&fixture.instance,
				std::mem::zeroed::<vk::PhysicalDevice>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<vk::SurfaceKHR>(),
				std::mem::zeroed::<*mut vk::Bool32>()
			),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceSurfaceSupportKHR"
			))
		));
		assert!(matches!(
			fixture.instance.get_physical_device_surface_support_khr(
				std::mem::zeroed::<vk::PhysicalDevice>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<vk::SurfaceKHR>(),
				std::mem::zeroed::<*mut vk::Bool32>()
			),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceSurfaceSupportKHR"
			))
		));
	}
}

#[test]
fn get_physical_device_surface_support_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::PhysicalDevice,
		arg_1: u32,
		arg_2: vk::SurfaceKHR,
		arg_3: *mut vk::Bool32,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::PhysicalDevice::from_raw(305397760_u64 as _)
					&& arg_1 == Default::default()
					&& arg_2 == vk::SurfaceKHR::from_raw(305398272_u64 as _)
					&& std::ptr::eq(
						arg_3,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::Bool32,
					)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetPhysicalDeviceSurfaceSupportKHR = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetPhysicalDeviceSurfaceSupportKHR,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkGetPhysicalDeviceSurfaceSupportKHR", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_physical_device_surface_support_khr(
					&fixture.instance,
					vk::PhysicalDevice::from_raw(305397760_u64 as _),
					Default::default(),
					vk::SurfaceKHR::from_raw(305398272_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::Bool32
				),
				expected
			);
			assert_eq!(
				vk::Instance::get_physical_device_surface_support_khr(
					&fixture.instance,
					vk::PhysicalDevice::from_raw(305397760_u64 as _),
					Default::default(),
					vk::SurfaceKHR::from_raw(305398272_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::Bool32
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_physical_device_surface_capabilities_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		vk::PhysicalDevice,
		vk::SurfaceKHR,
		*mut vk::SurfaceCapabilitiesKHR,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_physical_device_surface_capabilities_khr;
	let _: Signature = vk::Instance::get_physical_device_surface_capabilities_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_physical_device_surface_capabilities_khr(
				&fixture.instance,
				std::mem::zeroed::<vk::PhysicalDevice>(),
				std::mem::zeroed::<vk::SurfaceKHR>(),
				std::mem::zeroed::<*mut vk::SurfaceCapabilitiesKHR>()
			),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceSurfaceCapabilitiesKHR"
			))
		));
		assert!(matches!(
			fixture
				.instance
				.get_physical_device_surface_capabilities_khr(
					std::mem::zeroed::<vk::PhysicalDevice>(),
					std::mem::zeroed::<vk::SurfaceKHR>(),
					std::mem::zeroed::<*mut vk::SurfaceCapabilitiesKHR>()
				),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceSurfaceCapabilitiesKHR"
			))
		));
	}
}

#[test]
fn get_physical_device_surface_capabilities_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::PhysicalDevice,
		arg_1: vk::SurfaceKHR,
		arg_2: *mut vk::SurfaceCapabilitiesKHR,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::PhysicalDevice::from_raw(305397760_u64 as _)
					&& arg_1 == vk::SurfaceKHR::from_raw(305398016_u64 as _)
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *mut vk::SurfaceCapabilitiesKHR,
					)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkGetPhysicalDeviceSurfaceCapabilitiesKHR", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_physical_device_surface_capabilities_khr(
					&fixture.instance,
					vk::PhysicalDevice::from_raw(305397760_u64 as _),
					vk::SurfaceKHR::from_raw(305398016_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::SurfaceCapabilitiesKHR
				),
				expected
			);
			assert_eq!(
				vk::Instance::get_physical_device_surface_capabilities_khr(
					&fixture.instance,
					vk::PhysicalDevice::from_raw(305397760_u64 as _),
					vk::SurfaceKHR::from_raw(305398016_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::SurfaceCapabilitiesKHR
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_physical_device_surface_formats_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		vk::PhysicalDevice,
		vk::SurfaceKHR,
		*mut u32,
		*mut vk::SurfaceFormatKHR,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_physical_device_surface_formats_khr;
	let _: Signature = vk::Instance::get_physical_device_surface_formats_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_physical_device_surface_formats_khr(
				&fixture.instance,
				std::mem::zeroed::<vk::PhysicalDevice>(),
				std::mem::zeroed::<vk::SurfaceKHR>(),
				std::mem::zeroed::<*mut u32>(),
				std::mem::zeroed::<*mut vk::SurfaceFormatKHR>()
			),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceSurfaceFormatsKHR"
			))
		));
		assert!(matches!(
			fixture.instance.get_physical_device_surface_formats_khr(
				std::mem::zeroed::<vk::PhysicalDevice>(),
				std::mem::zeroed::<vk::SurfaceKHR>(),
				std::mem::zeroed::<*mut u32>(),
				std::mem::zeroed::<*mut vk::SurfaceFormatKHR>()
			),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceSurfaceFormatsKHR"
			))
		));
	}
}

#[test]
fn get_physical_device_surface_formats_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::PhysicalDevice,
		arg_1: vk::SurfaceKHR,
		arg_2: *mut u32,
		arg_3: *mut vk::SurfaceFormatKHR,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::PhysicalDevice::from_raw(305397760_u64 as _)
					&& arg_1 == vk::SurfaceKHR::from_raw(305398016_u64 as _)
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut u32,
					) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::SurfaceFormatKHR,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetPhysicalDeviceSurfaceFormatsKHR = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetPhysicalDeviceSurfaceFormatsKHR,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkGetPhysicalDeviceSurfaceFormatsKHR", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_physical_device_surface_formats_khr(
					&fixture.instance,
					vk::PhysicalDevice::from_raw(305397760_u64 as _),
					vk::SurfaceKHR::from_raw(305398016_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut u32,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::SurfaceFormatKHR
				),
				expected
			);
			assert_eq!(
				vk::Instance::get_physical_device_surface_formats_khr(
					&fixture.instance,
					vk::PhysicalDevice::from_raw(305397760_u64 as _),
					vk::SurfaceKHR::from_raw(305398016_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut u32,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::SurfaceFormatKHR
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_physical_device_surface_present_modes_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		vk::PhysicalDevice,
		vk::SurfaceKHR,
		*mut u32,
		*mut vk::PresentModeKHR,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_physical_device_surface_present_modes_khr;
	let _: Signature = vk::Instance::get_physical_device_surface_present_modes_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_physical_device_surface_present_modes_khr(
				&fixture.instance,
				std::mem::zeroed::<vk::PhysicalDevice>(),
				std::mem::zeroed::<vk::SurfaceKHR>(),
				std::mem::zeroed::<*mut u32>(),
				std::mem::zeroed::<*mut vk::PresentModeKHR>()
			),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceSurfacePresentModesKHR"
			))
		));
		assert!(matches!(
			fixture
				.instance
				.get_physical_device_surface_present_modes_khr(
					std::mem::zeroed::<vk::PhysicalDevice>(),
					std::mem::zeroed::<vk::SurfaceKHR>(),
					std::mem::zeroed::<*mut u32>(),
					std::mem::zeroed::<*mut vk::PresentModeKHR>()
				),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceSurfacePresentModesKHR"
			))
		));
	}
}

#[test]
fn get_physical_device_surface_present_modes_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::PhysicalDevice,
		arg_1: vk::SurfaceKHR,
		arg_2: *mut u32,
		arg_3: *mut vk::PresentModeKHR,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::PhysicalDevice::from_raw(305397760_u64 as _)
					&& arg_1 == vk::SurfaceKHR::from_raw(305398016_u64 as _)
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut u32,
					) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::PresentModeKHR,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetPhysicalDeviceSurfacePresentModesKHR = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetPhysicalDeviceSurfacePresentModesKHR,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkGetPhysicalDeviceSurfacePresentModesKHR", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_physical_device_surface_present_modes_khr(
					&fixture.instance,
					vk::PhysicalDevice::from_raw(305397760_u64 as _),
					vk::SurfaceKHR::from_raw(305398016_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut u32,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::PresentModeKHR
				),
				expected
			);
			assert_eq!(
				vk::Instance::get_physical_device_surface_present_modes_khr(
					&fixture.instance,
					vk::PhysicalDevice::from_raw(305397760_u64 as _),
					vk::SurfaceKHR::from_raw(305398016_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut u32,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::PresentModeKHR
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn create_swapchain_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::SwapchainCreateInfoKHR<'_>,
		*const vk::AllocationCallbacks,
		*mut vk::SwapchainKHR,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::create_swapchain_khr;
	let _: Signature = vk::Device::create_swapchain_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::create_swapchain_khr(
				&fixture.device,
				std::mem::zeroed::<*const vk::SwapchainCreateInfoKHR<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::SwapchainKHR>()
			),
			Err(CallError::MissingCommand("vkCreateSwapchainKHR"))
		));
		assert!(matches!(
			fixture.device.create_swapchain_khr(
				std::mem::zeroed::<*const vk::SwapchainCreateInfoKHR<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::SwapchainKHR>()
			),
			Err(CallError::MissingCommand("vkCreateSwapchainKHR"))
		));
	}
}

#[test]
fn create_swapchain_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::SwapchainCreateInfoKHR<'_>,
		arg_2: *const vk::AllocationCallbacks,
		arg_3: *mut vk::SwapchainKHR,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::SwapchainCreateInfoKHR<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
				) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::SwapchainKHR,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCreateSwapchainKHR = Some(mock);
		let erased = std::mem::transmute::<vk::PFN_vkCreateSwapchainKHR, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCreateSwapchainKHR", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::create_swapchain_khr(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::SwapchainCreateInfoKHR<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::SwapchainKHR
				),
				expected
			);
			assert_eq!(
				vk::Device::create_swapchain_khr(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::SwapchainCreateInfoKHR<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::SwapchainKHR
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn destroy_swapchain_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::SwapchainKHR,
		*const vk::AllocationCallbacks,
	) -> Result<(), CallError>;
	let _: Signature = vk::destroy_swapchain_khr;
	let _: Signature = vk::Device::destroy_swapchain_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::destroy_swapchain_khr(
				&fixture.device,
				std::mem::zeroed::<vk::SwapchainKHR>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>()
			),
			Err(CallError::MissingCommand("vkDestroySwapchainKHR"))
		));
		assert!(matches!(
			fixture.device.destroy_swapchain_khr(
				std::mem::zeroed::<vk::SwapchainKHR>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>()
			),
			Err(CallError::MissingCommand("vkDestroySwapchainKHR"))
		));
	}
}

#[test]
fn destroy_swapchain_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::SwapchainKHR,
		arg_2: *const vk::AllocationCallbacks,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::SwapchainKHR::from_raw(305398016_u64 as _)
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *const vk::AllocationCallbacks,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkDestroySwapchainKHR = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkDestroySwapchainKHR, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkDestroySwapchainKHR", erased);
		let resolutions = Fixture::query_count();
		vk::destroy_swapchain_khr(
			&fixture.device,
			vk::SwapchainKHR::from_raw(305398016_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::AllocationCallbacks,
		)
		.unwrap();
		vk::Device::destroy_swapchain_khr(
			&fixture.device,
			vk::SwapchainKHR::from_raw(305398016_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::AllocationCallbacks,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_swapchain_images_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::SwapchainKHR,
		*mut u32,
		*mut vk::Image,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_swapchain_images_khr;
	let _: Signature = vk::Device::get_swapchain_images_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_swapchain_images_khr(
				&fixture.device,
				std::mem::zeroed::<vk::SwapchainKHR>(),
				std::mem::zeroed::<*mut u32>(),
				std::mem::zeroed::<*mut vk::Image>()
			),
			Err(CallError::MissingCommand("vkGetSwapchainImagesKHR"))
		));
		assert!(matches!(
			fixture.device.get_swapchain_images_khr(
				std::mem::zeroed::<vk::SwapchainKHR>(),
				std::mem::zeroed::<*mut u32>(),
				std::mem::zeroed::<*mut vk::Image>()
			),
			Err(CallError::MissingCommand("vkGetSwapchainImagesKHR"))
		));
	}
}

#[test]
fn get_swapchain_images_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::SwapchainKHR,
		arg_2: *mut u32,
		arg_3: *mut vk::Image,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::SwapchainKHR::from_raw(305398016_u64 as _)
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut u32,
					) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::Image,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetSwapchainImagesKHR = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkGetSwapchainImagesKHR, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkGetSwapchainImagesKHR", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_swapchain_images_khr(
					&fixture.device,
					vk::SwapchainKHR::from_raw(305398016_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut u32,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::Image
				),
				expected
			);
			assert_eq!(
				vk::Device::get_swapchain_images_khr(
					&fixture.device,
					vk::SwapchainKHR::from_raw(305398016_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut u32,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::Image
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn acquire_next_image_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::SwapchainKHR,
		u64,
		vk::Semaphore,
		vk::Fence,
		*mut u32,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::acquire_next_image_khr;
	let _: Signature = vk::Device::acquire_next_image_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::acquire_next_image_khr(
				&fixture.device,
				std::mem::zeroed::<vk::SwapchainKHR>(),
				std::mem::zeroed::<u64>(),
				std::mem::zeroed::<vk::Semaphore>(),
				std::mem::zeroed::<vk::Fence>(),
				std::mem::zeroed::<*mut u32>()
			),
			Err(CallError::MissingCommand("vkAcquireNextImageKHR"))
		));
		assert!(matches!(
			fixture.device.acquire_next_image_khr(
				std::mem::zeroed::<vk::SwapchainKHR>(),
				std::mem::zeroed::<u64>(),
				std::mem::zeroed::<vk::Semaphore>(),
				std::mem::zeroed::<vk::Fence>(),
				std::mem::zeroed::<*mut u32>()
			),
			Err(CallError::MissingCommand("vkAcquireNextImageKHR"))
		));
	}
}

#[test]
fn acquire_next_image_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::SwapchainKHR,
		arg_2: u64,
		arg_3: vk::Semaphore,
		arg_4: vk::Fence,
		arg_5: *mut u32,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::SwapchainKHR::from_raw(305398016_u64 as _)
					&& arg_2 == Default::default()
					&& arg_3 == vk::Semaphore::from_raw(305398528_u64 as _)
					&& arg_4 == vk::Fence::from_raw(305398784_u64 as _)
					&& std::ptr::eq(
						arg_5,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305399040) as *mut u32,
					)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkAcquireNextImageKHR = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkAcquireNextImageKHR, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkAcquireNextImageKHR", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::acquire_next_image_khr(
					&fixture.device,
					vk::SwapchainKHR::from_raw(305398016_u64 as _),
					Default::default(),
					vk::Semaphore::from_raw(305398528_u64 as _),
					vk::Fence::from_raw(305398784_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305399040) as *mut u32
				),
				expected
			);
			assert_eq!(
				vk::Device::acquire_next_image_khr(
					&fixture.device,
					vk::SwapchainKHR::from_raw(305398016_u64 as _),
					Default::default(),
					vk::Semaphore::from_raw(305398528_u64 as _),
					vk::Fence::from_raw(305398784_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305399040) as *mut u32
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn queue_present_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::Queue,
		*const vk::PresentInfoKHR<'_>,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::queue_present_khr;
	let _: Signature = vk::Device::queue_present_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::queue_present_khr(
				&fixture.device,
				std::mem::zeroed::<vk::Queue>(),
				std::mem::zeroed::<*const vk::PresentInfoKHR<'_>>()
			),
			Err(CallError::MissingCommand("vkQueuePresentKHR"))
		));
		assert!(matches!(
			fixture.device.queue_present_khr(
				std::mem::zeroed::<vk::Queue>(),
				std::mem::zeroed::<*const vk::PresentInfoKHR<'_>>()
			),
			Err(CallError::MissingCommand("vkQueuePresentKHR"))
		));
	}
}

#[test]
fn queue_present_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::Queue,
		arg_1: *const vk::PresentInfoKHR<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::Queue::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::PresentInfoKHR<'_>,
					)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkQueuePresentKHR = Some(mock);
		let erased = std::mem::transmute::<vk::PFN_vkQueuePresentKHR, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkQueuePresentKHR", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::queue_present_khr(
					&fixture.device,
					vk::Queue::from_raw(305397760_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::PresentInfoKHR<'_>
				),
				expected
			);
			assert_eq!(
				vk::Device::queue_present_khr(
					&fixture.device,
					vk::Queue::from_raw(305397760_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::PresentInfoKHR<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[cfg(feature = "platform-vi")]
#[test]
fn create_vi_surface_nn_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		*const vk::ViSurfaceCreateInfoNN<'_>,
		*const vk::AllocationCallbacks,
		*mut vk::SurfaceKHR,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::create_vi_surface_nn;
	let _: Signature = vk::Instance::create_vi_surface_nn;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::create_vi_surface_nn(
				&fixture.instance,
				std::mem::zeroed::<*const vk::ViSurfaceCreateInfoNN<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::SurfaceKHR>()
			),
			Err(CallError::MissingCommand("vkCreateViSurfaceNN"))
		));
		assert!(matches!(
			fixture.instance.create_vi_surface_nn(
				std::mem::zeroed::<*const vk::ViSurfaceCreateInfoNN<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::SurfaceKHR>()
			),
			Err(CallError::MissingCommand("vkCreateViSurfaceNN"))
		));
	}
}

#[cfg(feature = "platform-vi")]
#[test]
fn create_vi_surface_nn_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::InstanceHandle,
		arg_1: *const vk::ViSurfaceCreateInfoNN<'_>,
		arg_2: *const vk::AllocationCallbacks,
		arg_3: *mut vk::SurfaceKHR,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::InstanceHandle::from_raw(0x1000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::ViSurfaceCreateInfoNN<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
				) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::SurfaceKHR,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCreateViSurfaceNN = Some(mock);
		let erased = std::mem::transmute::<vk::PFN_vkCreateViSurfaceNN, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCreateViSurfaceNN", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::create_vi_surface_nn(
					&fixture.instance,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::ViSurfaceCreateInfoNN<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::SurfaceKHR
				),
				expected
			);
			assert_eq!(
				vk::Instance::create_vi_surface_nn(
					&fixture.instance,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::ViSurfaceCreateInfoNN<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::SurfaceKHR
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[cfg(feature = "platform-wayland")]
#[test]
fn create_wayland_surface_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		*const vk::WaylandSurfaceCreateInfoKHR<'_>,
		*const vk::AllocationCallbacks,
		*mut vk::SurfaceKHR,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::create_wayland_surface_khr;
	let _: Signature = vk::Instance::create_wayland_surface_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::create_wayland_surface_khr(
				&fixture.instance,
				std::mem::zeroed::<*const vk::WaylandSurfaceCreateInfoKHR<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::SurfaceKHR>()
			),
			Err(CallError::MissingCommand("vkCreateWaylandSurfaceKHR"))
		));
		assert!(matches!(
			fixture.instance.create_wayland_surface_khr(
				std::mem::zeroed::<*const vk::WaylandSurfaceCreateInfoKHR<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::SurfaceKHR>()
			),
			Err(CallError::MissingCommand("vkCreateWaylandSurfaceKHR"))
		));
	}
}

#[cfg(feature = "platform-wayland")]
#[test]
fn create_wayland_surface_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::InstanceHandle,
		arg_1: *const vk::WaylandSurfaceCreateInfoKHR<'_>,
		arg_2: *const vk::AllocationCallbacks,
		arg_3: *mut vk::SurfaceKHR,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::InstanceHandle::from_raw(0x1000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::WaylandSurfaceCreateInfoKHR<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
				) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::SurfaceKHR,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCreateWaylandSurfaceKHR = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCreateWaylandSurfaceKHR, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCreateWaylandSurfaceKHR", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::create_wayland_surface_khr(
					&fixture.instance,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::WaylandSurfaceCreateInfoKHR<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::SurfaceKHR
				),
				expected
			);
			assert_eq!(
				vk::Instance::create_wayland_surface_khr(
					&fixture.instance,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::WaylandSurfaceCreateInfoKHR<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::SurfaceKHR
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[cfg(feature = "platform-wayland")]
#[test]
fn get_physical_device_wayland_presentation_support_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		vk::PhysicalDevice,
		u32,
		*mut vk::wl_display,
	) -> Result<vk::Bool32, CallError>;
	let _: Signature = vk::get_physical_device_wayland_presentation_support_khr;
	let _: Signature = vk::Instance::get_physical_device_wayland_presentation_support_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_physical_device_wayland_presentation_support_khr(
				&fixture.instance,
				std::mem::zeroed::<vk::PhysicalDevice>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*mut vk::wl_display>()
			),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceWaylandPresentationSupportKHR"
			))
		));
		assert!(matches!(
			fixture
				.instance
				.get_physical_device_wayland_presentation_support_khr(
					std::mem::zeroed::<vk::PhysicalDevice>(),
					std::mem::zeroed::<u32>(),
					std::mem::zeroed::<*mut vk::wl_display>()
				),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceWaylandPresentationSupportKHR"
			))
		));
	}
}

#[cfg(feature = "platform-wayland")]
#[test]
fn get_physical_device_wayland_presentation_support_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::PhysicalDevice,
		arg_1: u32,
		arg_2: *mut vk::wl_display,
	) -> vk::Bool32 {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::PhysicalDevice::from_raw(305397760_u64 as _)
					&& arg_1 == Default::default()
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut vk::wl_display,
					)),
		);
		0xfedc_ba98_7654_3210_u64 as vk::Bool32
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture =
			Fixture::new_with_command(c"vkGetPhysicalDeviceWaylandPresentationSupportKHR", erased);
		let resolutions = Fixture::query_count();
		assert_eq!(
			vk::get_physical_device_wayland_presentation_support_khr(
				&fixture.instance,
				vk::PhysicalDevice::from_raw(305397760_u64 as _),
				Default::default(),
				std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut vk::wl_display
			)
			.unwrap(),
			0xfedc_ba98_7654_3210_u64 as vk::Bool32
		);
		assert_eq!(
			vk::Instance::get_physical_device_wayland_presentation_support_khr(
				&fixture.instance,
				vk::PhysicalDevice::from_raw(305397760_u64 as _),
				Default::default(),
				std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut vk::wl_display
			)
			.unwrap(),
			0xfedc_ba98_7654_3210_u64 as vk::Bool32
		);
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[cfg(feature = "platform-ubm")]
#[test]
fn create_ubm_surface_sec_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		*const vk::UbmSurfaceCreateInfoSEC<'_>,
		*const vk::AllocationCallbacks,
		*mut vk::SurfaceKHR,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::create_ubm_surface_sec;
	let _: Signature = vk::Instance::create_ubm_surface_sec;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::create_ubm_surface_sec(
				&fixture.instance,
				std::mem::zeroed::<*const vk::UbmSurfaceCreateInfoSEC<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::SurfaceKHR>()
			),
			Err(CallError::MissingCommand("vkCreateUbmSurfaceSEC"))
		));
		assert!(matches!(
			fixture.instance.create_ubm_surface_sec(
				std::mem::zeroed::<*const vk::UbmSurfaceCreateInfoSEC<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::SurfaceKHR>()
			),
			Err(CallError::MissingCommand("vkCreateUbmSurfaceSEC"))
		));
	}
}

#[cfg(feature = "platform-ubm")]
#[test]
fn create_ubm_surface_sec_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::InstanceHandle,
		arg_1: *const vk::UbmSurfaceCreateInfoSEC<'_>,
		arg_2: *const vk::AllocationCallbacks,
		arg_3: *mut vk::SurfaceKHR,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::InstanceHandle::from_raw(0x1000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::UbmSurfaceCreateInfoSEC<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
				) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::SurfaceKHR,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCreateUbmSurfaceSEC = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCreateUbmSurfaceSEC, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCreateUbmSurfaceSEC", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::create_ubm_surface_sec(
					&fixture.instance,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::UbmSurfaceCreateInfoSEC<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::SurfaceKHR
				),
				expected
			);
			assert_eq!(
				vk::Instance::create_ubm_surface_sec(
					&fixture.instance,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::UbmSurfaceCreateInfoSEC<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::SurfaceKHR
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[cfg(feature = "platform-ubm")]
#[test]
fn get_physical_device_ubm_presentation_support_sec_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		vk::PhysicalDevice,
		u32,
		*mut vk::ubm_device,
	) -> Result<vk::Bool32, CallError>;
	let _: Signature = vk::get_physical_device_ubm_presentation_support_sec;
	let _: Signature = vk::Instance::get_physical_device_ubm_presentation_support_sec;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_physical_device_ubm_presentation_support_sec(
				&fixture.instance,
				std::mem::zeroed::<vk::PhysicalDevice>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*mut vk::ubm_device>()
			),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceUbmPresentationSupportSEC"
			))
		));
		assert!(matches!(
			fixture
				.instance
				.get_physical_device_ubm_presentation_support_sec(
					std::mem::zeroed::<vk::PhysicalDevice>(),
					std::mem::zeroed::<u32>(),
					std::mem::zeroed::<*mut vk::ubm_device>()
				),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceUbmPresentationSupportSEC"
			))
		));
	}
}

#[cfg(feature = "platform-ubm")]
#[test]
fn get_physical_device_ubm_presentation_support_sec_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::PhysicalDevice,
		arg_1: u32,
		arg_2: *mut vk::ubm_device,
	) -> vk::Bool32 {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::PhysicalDevice::from_raw(305397760_u64 as _)
					&& arg_1 == Default::default()
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut vk::ubm_device,
					)),
		);
		0xfedc_ba98_7654_3210_u64 as vk::Bool32
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetPhysicalDeviceUbmPresentationSupportSEC = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetPhysicalDeviceUbmPresentationSupportSEC,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture =
			Fixture::new_with_command(c"vkGetPhysicalDeviceUbmPresentationSupportSEC", erased);
		let resolutions = Fixture::query_count();
		assert_eq!(
			vk::get_physical_device_ubm_presentation_support_sec(
				&fixture.instance,
				vk::PhysicalDevice::from_raw(305397760_u64 as _),
				Default::default(),
				std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut vk::ubm_device
			)
			.unwrap(),
			0xfedc_ba98_7654_3210_u64 as vk::Bool32
		);
		assert_eq!(
			vk::Instance::get_physical_device_ubm_presentation_support_sec(
				&fixture.instance,
				vk::PhysicalDevice::from_raw(305397760_u64 as _),
				Default::default(),
				std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut vk::ubm_device
			)
			.unwrap(),
			0xfedc_ba98_7654_3210_u64 as vk::Bool32
		);
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[cfg(feature = "platform-win32")]
#[test]
fn create_win32_surface_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		*const vk::Win32SurfaceCreateInfoKHR<'_>,
		*const vk::AllocationCallbacks,
		*mut vk::SurfaceKHR,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::create_win32_surface_khr;
	let _: Signature = vk::Instance::create_win32_surface_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::create_win32_surface_khr(
				&fixture.instance,
				std::mem::zeroed::<*const vk::Win32SurfaceCreateInfoKHR<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::SurfaceKHR>()
			),
			Err(CallError::MissingCommand("vkCreateWin32SurfaceKHR"))
		));
		assert!(matches!(
			fixture.instance.create_win32_surface_khr(
				std::mem::zeroed::<*const vk::Win32SurfaceCreateInfoKHR<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::SurfaceKHR>()
			),
			Err(CallError::MissingCommand("vkCreateWin32SurfaceKHR"))
		));
	}
}

#[cfg(feature = "platform-win32")]
#[test]
fn create_win32_surface_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::InstanceHandle,
		arg_1: *const vk::Win32SurfaceCreateInfoKHR<'_>,
		arg_2: *const vk::AllocationCallbacks,
		arg_3: *mut vk::SurfaceKHR,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::InstanceHandle::from_raw(0x1000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::Win32SurfaceCreateInfoKHR<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
				) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::SurfaceKHR,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCreateWin32SurfaceKHR = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCreateWin32SurfaceKHR, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCreateWin32SurfaceKHR", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::create_win32_surface_khr(
					&fixture.instance,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::Win32SurfaceCreateInfoKHR<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::SurfaceKHR
				),
				expected
			);
			assert_eq!(
				vk::Instance::create_win32_surface_khr(
					&fixture.instance,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::Win32SurfaceCreateInfoKHR<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::SurfaceKHR
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[cfg(feature = "platform-win32")]
#[test]
fn get_physical_device_win32_presentation_support_khr_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Instance, vk::PhysicalDevice, u32) -> Result<vk::Bool32, CallError>;
	let _: Signature = vk::get_physical_device_win32_presentation_support_khr;
	let _: Signature = vk::Instance::get_physical_device_win32_presentation_support_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_physical_device_win32_presentation_support_khr(
				&fixture.instance,
				std::mem::zeroed::<vk::PhysicalDevice>(),
				std::mem::zeroed::<u32>()
			),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceWin32PresentationSupportKHR"
			))
		));
		assert!(matches!(
			fixture
				.instance
				.get_physical_device_win32_presentation_support_khr(
					std::mem::zeroed::<vk::PhysicalDevice>(),
					std::mem::zeroed::<u32>()
				),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceWin32PresentationSupportKHR"
			))
		));
	}
}

#[cfg(feature = "platform-win32")]
#[test]
fn get_physical_device_win32_presentation_support_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::PhysicalDevice, arg_1: u32) -> vk::Bool32 {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::PhysicalDevice::from_raw(305397760_u64 as _)
					&& arg_1 == Default::default()),
		);
		0xfedc_ba98_7654_3210_u64 as vk::Bool32
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture =
			Fixture::new_with_command(c"vkGetPhysicalDeviceWin32PresentationSupportKHR", erased);
		let resolutions = Fixture::query_count();
		assert_eq!(
			vk::get_physical_device_win32_presentation_support_khr(
				&fixture.instance,
				vk::PhysicalDevice::from_raw(305397760_u64 as _),
				Default::default()
			)
			.unwrap(),
			0xfedc_ba98_7654_3210_u64 as vk::Bool32
		);
		assert_eq!(
			vk::Instance::get_physical_device_win32_presentation_support_khr(
				&fixture.instance,
				vk::PhysicalDevice::from_raw(305397760_u64 as _),
				Default::default()
			)
			.unwrap(),
			0xfedc_ba98_7654_3210_u64 as vk::Bool32
		);
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[cfg(feature = "platform-xlib")]
#[test]
fn create_xlib_surface_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		*const vk::XlibSurfaceCreateInfoKHR<'_>,
		*const vk::AllocationCallbacks,
		*mut vk::SurfaceKHR,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::create_xlib_surface_khr;
	let _: Signature = vk::Instance::create_xlib_surface_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::create_xlib_surface_khr(
				&fixture.instance,
				std::mem::zeroed::<*const vk::XlibSurfaceCreateInfoKHR<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::SurfaceKHR>()
			),
			Err(CallError::MissingCommand("vkCreateXlibSurfaceKHR"))
		));
		assert!(matches!(
			fixture.instance.create_xlib_surface_khr(
				std::mem::zeroed::<*const vk::XlibSurfaceCreateInfoKHR<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::SurfaceKHR>()
			),
			Err(CallError::MissingCommand("vkCreateXlibSurfaceKHR"))
		));
	}
}

#[cfg(feature = "platform-xlib")]
#[test]
fn create_xlib_surface_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::InstanceHandle,
		arg_1: *const vk::XlibSurfaceCreateInfoKHR<'_>,
		arg_2: *const vk::AllocationCallbacks,
		arg_3: *mut vk::SurfaceKHR,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::InstanceHandle::from_raw(0x1000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::XlibSurfaceCreateInfoKHR<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
				) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::SurfaceKHR,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCreateXlibSurfaceKHR = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCreateXlibSurfaceKHR, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCreateXlibSurfaceKHR", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::create_xlib_surface_khr(
					&fixture.instance,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::XlibSurfaceCreateInfoKHR<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::SurfaceKHR
				),
				expected
			);
			assert_eq!(
				vk::Instance::create_xlib_surface_khr(
					&fixture.instance,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::XlibSurfaceCreateInfoKHR<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::SurfaceKHR
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[cfg(feature = "platform-xlib")]
#[test]
fn get_physical_device_xlib_presentation_support_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		vk::PhysicalDevice,
		u32,
		*mut vk::Display,
		vk::VisualID,
	) -> Result<vk::Bool32, CallError>;
	let _: Signature = vk::get_physical_device_xlib_presentation_support_khr;
	let _: Signature = vk::Instance::get_physical_device_xlib_presentation_support_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_physical_device_xlib_presentation_support_khr(
				&fixture.instance,
				std::mem::zeroed::<vk::PhysicalDevice>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*mut vk::Display>(),
				std::mem::zeroed::<vk::VisualID>()
			),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceXlibPresentationSupportKHR"
			))
		));
		assert!(matches!(
			fixture
				.instance
				.get_physical_device_xlib_presentation_support_khr(
					std::mem::zeroed::<vk::PhysicalDevice>(),
					std::mem::zeroed::<u32>(),
					std::mem::zeroed::<*mut vk::Display>(),
					std::mem::zeroed::<vk::VisualID>()
				),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceXlibPresentationSupportKHR"
			))
		));
	}
}

#[cfg(feature = "platform-xlib")]
#[test]
fn get_physical_device_xlib_presentation_support_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::PhysicalDevice,
		arg_1: u32,
		arg_2: *mut vk::Display,
		arg_3: vk::VisualID,
	) -> vk::Bool32 {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::PhysicalDevice::from_raw(305397760_u64 as _)
					&& arg_1 == Default::default()
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut vk::Display,
					) && arg_3 == Default::default()),
		);
		0xfedc_ba98_7654_3210_u64 as vk::Bool32
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture =
			Fixture::new_with_command(c"vkGetPhysicalDeviceXlibPresentationSupportKHR", erased);
		let resolutions = Fixture::query_count();
		assert_eq!(
			vk::get_physical_device_xlib_presentation_support_khr(
				&fixture.instance,
				vk::PhysicalDevice::from_raw(305397760_u64 as _),
				Default::default(),
				std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut vk::Display,
				Default::default()
			)
			.unwrap(),
			0xfedc_ba98_7654_3210_u64 as vk::Bool32
		);
		assert_eq!(
			vk::Instance::get_physical_device_xlib_presentation_support_khr(
				&fixture.instance,
				vk::PhysicalDevice::from_raw(305397760_u64 as _),
				Default::default(),
				std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut vk::Display,
				Default::default()
			)
			.unwrap(),
			0xfedc_ba98_7654_3210_u64 as vk::Bool32
		);
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[cfg(feature = "platform-xcb")]
#[test]
fn create_xcb_surface_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		*const vk::XcbSurfaceCreateInfoKHR<'_>,
		*const vk::AllocationCallbacks,
		*mut vk::SurfaceKHR,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::create_xcb_surface_khr;
	let _: Signature = vk::Instance::create_xcb_surface_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::create_xcb_surface_khr(
				&fixture.instance,
				std::mem::zeroed::<*const vk::XcbSurfaceCreateInfoKHR<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::SurfaceKHR>()
			),
			Err(CallError::MissingCommand("vkCreateXcbSurfaceKHR"))
		));
		assert!(matches!(
			fixture.instance.create_xcb_surface_khr(
				std::mem::zeroed::<*const vk::XcbSurfaceCreateInfoKHR<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::SurfaceKHR>()
			),
			Err(CallError::MissingCommand("vkCreateXcbSurfaceKHR"))
		));
	}
}

#[cfg(feature = "platform-xcb")]
#[test]
fn create_xcb_surface_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::InstanceHandle,
		arg_1: *const vk::XcbSurfaceCreateInfoKHR<'_>,
		arg_2: *const vk::AllocationCallbacks,
		arg_3: *mut vk::SurfaceKHR,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::InstanceHandle::from_raw(0x1000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::XcbSurfaceCreateInfoKHR<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
				) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::SurfaceKHR,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCreateXcbSurfaceKHR = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCreateXcbSurfaceKHR, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCreateXcbSurfaceKHR", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::create_xcb_surface_khr(
					&fixture.instance,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::XcbSurfaceCreateInfoKHR<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::SurfaceKHR
				),
				expected
			);
			assert_eq!(
				vk::Instance::create_xcb_surface_khr(
					&fixture.instance,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::XcbSurfaceCreateInfoKHR<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::SurfaceKHR
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[cfg(feature = "platform-xcb")]
#[test]
fn get_physical_device_xcb_presentation_support_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		vk::PhysicalDevice,
		u32,
		*mut vk::xcb_connection_t,
		vk::xcb_visualid_t,
	) -> Result<vk::Bool32, CallError>;
	let _: Signature = vk::get_physical_device_xcb_presentation_support_khr;
	let _: Signature = vk::Instance::get_physical_device_xcb_presentation_support_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_physical_device_xcb_presentation_support_khr(
				&fixture.instance,
				std::mem::zeroed::<vk::PhysicalDevice>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*mut vk::xcb_connection_t>(),
				std::mem::zeroed::<vk::xcb_visualid_t>()
			),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceXcbPresentationSupportKHR"
			))
		));
		assert!(matches!(
			fixture
				.instance
				.get_physical_device_xcb_presentation_support_khr(
					std::mem::zeroed::<vk::PhysicalDevice>(),
					std::mem::zeroed::<u32>(),
					std::mem::zeroed::<*mut vk::xcb_connection_t>(),
					std::mem::zeroed::<vk::xcb_visualid_t>()
				),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceXcbPresentationSupportKHR"
			))
		));
	}
}

#[cfg(feature = "platform-xcb")]
#[test]
fn get_physical_device_xcb_presentation_support_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::PhysicalDevice,
		arg_1: u32,
		arg_2: *mut vk::xcb_connection_t,
		arg_3: vk::xcb_visualid_t,
	) -> vk::Bool32 {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::PhysicalDevice::from_raw(305397760_u64 as _)
					&& arg_1 == Default::default()
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *mut vk::xcb_connection_t,
					) && arg_3 == Default::default()),
		);
		0xfedc_ba98_7654_3210_u64 as vk::Bool32
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture =
			Fixture::new_with_command(c"vkGetPhysicalDeviceXcbPresentationSupportKHR", erased);
		let resolutions = Fixture::query_count();
		assert_eq!(
			vk::get_physical_device_xcb_presentation_support_khr(
				&fixture.instance,
				vk::PhysicalDevice::from_raw(305397760_u64 as _),
				Default::default(),
				std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
					as *mut vk::xcb_connection_t,
				Default::default()
			)
			.unwrap(),
			0xfedc_ba98_7654_3210_u64 as vk::Bool32
		);
		assert_eq!(
			vk::Instance::get_physical_device_xcb_presentation_support_khr(
				&fixture.instance,
				vk::PhysicalDevice::from_raw(305397760_u64 as _),
				Default::default(),
				std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
					as *mut vk::xcb_connection_t,
				Default::default()
			)
			.unwrap(),
			0xfedc_ba98_7654_3210_u64 as vk::Bool32
		);
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[cfg(feature = "platform-directfb")]
#[test]
fn create_direct_fb_surface_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		*const vk::DirectFBSurfaceCreateInfoEXT<'_>,
		*const vk::AllocationCallbacks,
		*mut vk::SurfaceKHR,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::create_direct_fb_surface_ext;
	let _: Signature = vk::Instance::create_direct_fb_surface_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::create_direct_fb_surface_ext(
				&fixture.instance,
				std::mem::zeroed::<*const vk::DirectFBSurfaceCreateInfoEXT<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::SurfaceKHR>()
			),
			Err(CallError::MissingCommand("vkCreateDirectFBSurfaceEXT"))
		));
		assert!(matches!(
			fixture.instance.create_direct_fb_surface_ext(
				std::mem::zeroed::<*const vk::DirectFBSurfaceCreateInfoEXT<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::SurfaceKHR>()
			),
			Err(CallError::MissingCommand("vkCreateDirectFBSurfaceEXT"))
		));
	}
}

#[cfg(feature = "platform-directfb")]
#[test]
fn create_direct_fb_surface_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::InstanceHandle,
		arg_1: *const vk::DirectFBSurfaceCreateInfoEXT<'_>,
		arg_2: *const vk::AllocationCallbacks,
		arg_3: *mut vk::SurfaceKHR,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::InstanceHandle::from_raw(0x1000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::DirectFBSurfaceCreateInfoEXT<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
				) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::SurfaceKHR,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCreateDirectFBSurfaceEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCreateDirectFBSurfaceEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCreateDirectFBSurfaceEXT", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::create_direct_fb_surface_ext(
					&fixture.instance,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::DirectFBSurfaceCreateInfoEXT<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::SurfaceKHR
				),
				expected
			);
			assert_eq!(
				vk::Instance::create_direct_fb_surface_ext(
					&fixture.instance,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::DirectFBSurfaceCreateInfoEXT<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::SurfaceKHR
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[cfg(feature = "platform-directfb")]
#[test]
fn get_physical_device_direct_fb_presentation_support_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		vk::PhysicalDevice,
		u32,
		*mut vk::IDirectFB,
	) -> Result<vk::Bool32, CallError>;
	let _: Signature = vk::get_physical_device_direct_fb_presentation_support_ext;
	let _: Signature = vk::Instance::get_physical_device_direct_fb_presentation_support_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_physical_device_direct_fb_presentation_support_ext(
				&fixture.instance,
				std::mem::zeroed::<vk::PhysicalDevice>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*mut vk::IDirectFB>()
			),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceDirectFBPresentationSupportEXT"
			))
		));
		assert!(matches!(
			fixture
				.instance
				.get_physical_device_direct_fb_presentation_support_ext(
					std::mem::zeroed::<vk::PhysicalDevice>(),
					std::mem::zeroed::<u32>(),
					std::mem::zeroed::<*mut vk::IDirectFB>()
				),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceDirectFBPresentationSupportEXT"
			))
		));
	}
}

#[cfg(feature = "platform-directfb")]
#[test]
fn get_physical_device_direct_fb_presentation_support_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::PhysicalDevice,
		arg_1: u32,
		arg_2: *mut vk::IDirectFB,
	) -> vk::Bool32 {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::PhysicalDevice::from_raw(305397760_u64 as _)
					&& arg_1 == Default::default()
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut vk::IDirectFB,
					)),
		);
		0xfedc_ba98_7654_3210_u64 as vk::Bool32
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetPhysicalDeviceDirectFBPresentationSupportEXT = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetPhysicalDeviceDirectFBPresentationSupportEXT,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture =
			Fixture::new_with_command(c"vkGetPhysicalDeviceDirectFBPresentationSupportEXT", erased);
		let resolutions = Fixture::query_count();
		assert_eq!(
			vk::get_physical_device_direct_fb_presentation_support_ext(
				&fixture.instance,
				vk::PhysicalDevice::from_raw(305397760_u64 as _),
				Default::default(),
				std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut vk::IDirectFB
			)
			.unwrap(),
			0xfedc_ba98_7654_3210_u64 as vk::Bool32
		);
		assert_eq!(
			vk::Instance::get_physical_device_direct_fb_presentation_support_ext(
				&fixture.instance,
				vk::PhysicalDevice::from_raw(305397760_u64 as _),
				Default::default(),
				std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut vk::IDirectFB
			)
			.unwrap(),
			0xfedc_ba98_7654_3210_u64 as vk::Bool32
		);
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[cfg(feature = "platform-fuchsia")]
#[test]
fn create_image_pipe_surface_fuchsia_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		*const vk::ImagePipeSurfaceCreateInfoFUCHSIA<'_>,
		*const vk::AllocationCallbacks,
		*mut vk::SurfaceKHR,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::create_image_pipe_surface_fuchsia;
	let _: Signature = vk::Instance::create_image_pipe_surface_fuchsia;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::create_image_pipe_surface_fuchsia(
				&fixture.instance,
				std::mem::zeroed::<*const vk::ImagePipeSurfaceCreateInfoFUCHSIA<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::SurfaceKHR>()
			),
			Err(CallError::MissingCommand("vkCreateImagePipeSurfaceFUCHSIA"))
		));
		assert!(matches!(
			fixture.instance.create_image_pipe_surface_fuchsia(
				std::mem::zeroed::<*const vk::ImagePipeSurfaceCreateInfoFUCHSIA<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::SurfaceKHR>()
			),
			Err(CallError::MissingCommand("vkCreateImagePipeSurfaceFUCHSIA"))
		));
	}
}

#[cfg(feature = "platform-fuchsia")]
#[test]
fn create_image_pipe_surface_fuchsia_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::InstanceHandle,
		arg_1: *const vk::ImagePipeSurfaceCreateInfoFUCHSIA<'_>,
		arg_2: *const vk::AllocationCallbacks,
		arg_3: *mut vk::SurfaceKHR,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::InstanceHandle::from_raw(0x1000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::ImagePipeSurfaceCreateInfoFUCHSIA<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
				) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::SurfaceKHR,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCreateImagePipeSurfaceFUCHSIA = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCreateImagePipeSurfaceFUCHSIA, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCreateImagePipeSurfaceFUCHSIA", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::create_image_pipe_surface_fuchsia(
					&fixture.instance,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::ImagePipeSurfaceCreateInfoFUCHSIA<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::SurfaceKHR
				),
				expected
			);
			assert_eq!(
				vk::Instance::create_image_pipe_surface_fuchsia(
					&fixture.instance,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::ImagePipeSurfaceCreateInfoFUCHSIA<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::SurfaceKHR
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[cfg(feature = "platform-ggp")]
#[test]
fn create_stream_descriptor_surface_ggp_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		*const vk::StreamDescriptorSurfaceCreateInfoGGP<'_>,
		*const vk::AllocationCallbacks,
		*mut vk::SurfaceKHR,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::create_stream_descriptor_surface_ggp;
	let _: Signature = vk::Instance::create_stream_descriptor_surface_ggp;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::create_stream_descriptor_surface_ggp(
				&fixture.instance,
				std::mem::zeroed::<*const vk::StreamDescriptorSurfaceCreateInfoGGP<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::SurfaceKHR>()
			),
			Err(CallError::MissingCommand(
				"vkCreateStreamDescriptorSurfaceGGP"
			))
		));
		assert!(matches!(
			fixture.instance.create_stream_descriptor_surface_ggp(
				std::mem::zeroed::<*const vk::StreamDescriptorSurfaceCreateInfoGGP<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::SurfaceKHR>()
			),
			Err(CallError::MissingCommand(
				"vkCreateStreamDescriptorSurfaceGGP"
			))
		));
	}
}

#[cfg(feature = "platform-ggp")]
#[test]
fn create_stream_descriptor_surface_ggp_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::InstanceHandle,
		arg_1: *const vk::StreamDescriptorSurfaceCreateInfoGGP<'_>,
		arg_2: *const vk::AllocationCallbacks,
		arg_3: *mut vk::SurfaceKHR,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::InstanceHandle::from_raw(0x1000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::StreamDescriptorSurfaceCreateInfoGGP<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
				) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::SurfaceKHR,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCreateStreamDescriptorSurfaceGGP = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkCreateStreamDescriptorSurfaceGGP,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkCreateStreamDescriptorSurfaceGGP", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::create_stream_descriptor_surface_ggp(
					&fixture.instance,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::StreamDescriptorSurfaceCreateInfoGGP<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::SurfaceKHR
				),
				expected
			);
			assert_eq!(
				vk::Instance::create_stream_descriptor_surface_ggp(
					&fixture.instance,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::StreamDescriptorSurfaceCreateInfoGGP<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::SurfaceKHR
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[cfg(feature = "platform-screen")]
#[test]
fn create_screen_surface_qnx_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		*const vk::ScreenSurfaceCreateInfoQNX<'_>,
		*const vk::AllocationCallbacks,
		*mut vk::SurfaceKHR,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::create_screen_surface_qnx;
	let _: Signature = vk::Instance::create_screen_surface_qnx;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::create_screen_surface_qnx(
				&fixture.instance,
				std::mem::zeroed::<*const vk::ScreenSurfaceCreateInfoQNX<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::SurfaceKHR>()
			),
			Err(CallError::MissingCommand("vkCreateScreenSurfaceQNX"))
		));
		assert!(matches!(
			fixture.instance.create_screen_surface_qnx(
				std::mem::zeroed::<*const vk::ScreenSurfaceCreateInfoQNX<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::SurfaceKHR>()
			),
			Err(CallError::MissingCommand("vkCreateScreenSurfaceQNX"))
		));
	}
}

#[cfg(feature = "platform-screen")]
#[test]
fn create_screen_surface_qnx_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::InstanceHandle,
		arg_1: *const vk::ScreenSurfaceCreateInfoQNX<'_>,
		arg_2: *const vk::AllocationCallbacks,
		arg_3: *mut vk::SurfaceKHR,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::InstanceHandle::from_raw(0x1000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::ScreenSurfaceCreateInfoQNX<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
				) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::SurfaceKHR,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCreateScreenSurfaceQNX = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCreateScreenSurfaceQNX, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCreateScreenSurfaceQNX", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::create_screen_surface_qnx(
					&fixture.instance,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::ScreenSurfaceCreateInfoQNX<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::SurfaceKHR
				),
				expected
			);
			assert_eq!(
				vk::Instance::create_screen_surface_qnx(
					&fixture.instance,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::ScreenSurfaceCreateInfoQNX<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::SurfaceKHR
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[cfg(feature = "platform-screen")]
#[test]
fn get_physical_device_screen_presentation_support_qnx_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		vk::PhysicalDevice,
		u32,
		*mut vk::_screen_window,
	) -> Result<vk::Bool32, CallError>;
	let _: Signature = vk::get_physical_device_screen_presentation_support_qnx;
	let _: Signature = vk::Instance::get_physical_device_screen_presentation_support_qnx;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_physical_device_screen_presentation_support_qnx(
				&fixture.instance,
				std::mem::zeroed::<vk::PhysicalDevice>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*mut vk::_screen_window>()
			),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceScreenPresentationSupportQNX"
			))
		));
		assert!(matches!(
			fixture
				.instance
				.get_physical_device_screen_presentation_support_qnx(
					std::mem::zeroed::<vk::PhysicalDevice>(),
					std::mem::zeroed::<u32>(),
					std::mem::zeroed::<*mut vk::_screen_window>()
				),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceScreenPresentationSupportQNX"
			))
		));
	}
}

#[cfg(feature = "platform-screen")]
#[test]
fn get_physical_device_screen_presentation_support_qnx_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::PhysicalDevice,
		arg_1: u32,
		arg_2: *mut vk::_screen_window,
	) -> vk::Bool32 {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::PhysicalDevice::from_raw(305397760_u64 as _)
					&& arg_1 == Default::default()
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *mut vk::_screen_window,
					)),
		);
		0xfedc_ba98_7654_3210_u64 as vk::Bool32
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture =
			Fixture::new_with_command(c"vkGetPhysicalDeviceScreenPresentationSupportQNX", erased);
		let resolutions = Fixture::query_count();
		assert_eq!(
			vk::get_physical_device_screen_presentation_support_qnx(
				&fixture.instance,
				vk::PhysicalDevice::from_raw(305397760_u64 as _),
				Default::default(),
				std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut vk::_screen_window
			)
			.unwrap(),
			0xfedc_ba98_7654_3210_u64 as vk::Bool32
		);
		assert_eq!(
			vk::Instance::get_physical_device_screen_presentation_support_qnx(
				&fixture.instance,
				vk::PhysicalDevice::from_raw(305397760_u64 as _),
				Default::default(),
				std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut vk::_screen_window
			)
			.unwrap(),
			0xfedc_ba98_7654_3210_u64 as vk::Bool32
		);
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn create_debug_report_callback_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		*const vk::DebugReportCallbackCreateInfoEXT<'_>,
		*const vk::AllocationCallbacks,
		*mut vk::DebugReportCallbackEXT,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::create_debug_report_callback_ext;
	let _: Signature = vk::Instance::create_debug_report_callback_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::create_debug_report_callback_ext(
				&fixture.instance,
				std::mem::zeroed::<*const vk::DebugReportCallbackCreateInfoEXT<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::DebugReportCallbackEXT>()
			),
			Err(CallError::MissingCommand("vkCreateDebugReportCallbackEXT"))
		));
		assert!(matches!(
			fixture.instance.create_debug_report_callback_ext(
				std::mem::zeroed::<*const vk::DebugReportCallbackCreateInfoEXT<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::DebugReportCallbackEXT>()
			),
			Err(CallError::MissingCommand("vkCreateDebugReportCallbackEXT"))
		));
	}
}

#[test]
fn create_debug_report_callback_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::InstanceHandle,
		arg_1: *const vk::DebugReportCallbackCreateInfoEXT<'_>,
		arg_2: *const vk::AllocationCallbacks,
		arg_3: *mut vk::DebugReportCallbackEXT,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::InstanceHandle::from_raw(0x1000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::DebugReportCallbackCreateInfoEXT<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
				) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::DebugReportCallbackEXT,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCreateDebugReportCallbackEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCreateDebugReportCallbackEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCreateDebugReportCallbackEXT", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::create_debug_report_callback_ext(
					&fixture.instance,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::DebugReportCallbackCreateInfoEXT<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::DebugReportCallbackEXT
				),
				expected
			);
			assert_eq!(
				vk::Instance::create_debug_report_callback_ext(
					&fixture.instance,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::DebugReportCallbackCreateInfoEXT<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::DebugReportCallbackEXT
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn destroy_debug_report_callback_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		vk::DebugReportCallbackEXT,
		*const vk::AllocationCallbacks,
	) -> Result<(), CallError>;
	let _: Signature = vk::destroy_debug_report_callback_ext;
	let _: Signature = vk::Instance::destroy_debug_report_callback_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::destroy_debug_report_callback_ext(
				&fixture.instance,
				std::mem::zeroed::<vk::DebugReportCallbackEXT>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>()
			),
			Err(CallError::MissingCommand("vkDestroyDebugReportCallbackEXT"))
		));
		assert!(matches!(
			fixture.instance.destroy_debug_report_callback_ext(
				std::mem::zeroed::<vk::DebugReportCallbackEXT>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>()
			),
			Err(CallError::MissingCommand("vkDestroyDebugReportCallbackEXT"))
		));
	}
}

#[test]
fn destroy_debug_report_callback_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::InstanceHandle,
		arg_1: vk::DebugReportCallbackEXT,
		arg_2: *const vk::AllocationCallbacks,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::InstanceHandle::from_raw(0x1000)
					&& arg_1 == vk::DebugReportCallbackEXT::from_raw(305398016_u64 as _)
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *const vk::AllocationCallbacks,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkDestroyDebugReportCallbackEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkDestroyDebugReportCallbackEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkDestroyDebugReportCallbackEXT", erased);
		let resolutions = Fixture::query_count();
		vk::destroy_debug_report_callback_ext(
			&fixture.instance,
			vk::DebugReportCallbackEXT::from_raw(305398016_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::AllocationCallbacks,
		)
		.unwrap();
		vk::Instance::destroy_debug_report_callback_ext(
			&fixture.instance,
			vk::DebugReportCallbackEXT::from_raw(305398016_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::AllocationCallbacks,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn debug_report_message_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		vk::DebugReportFlagsEXT,
		vk::DebugReportObjectTypeEXT,
		u64,
		usize,
		i32,
		*const std::ffi::c_char,
		*const std::ffi::c_char,
	) -> Result<(), CallError>;
	let _: Signature = vk::debug_report_message_ext;
	let _: Signature = vk::Instance::debug_report_message_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::debug_report_message_ext(
				&fixture.instance,
				std::mem::zeroed::<vk::DebugReportFlagsEXT>(),
				std::mem::zeroed::<vk::DebugReportObjectTypeEXT>(),
				std::mem::zeroed::<u64>(),
				std::mem::zeroed::<usize>(),
				std::mem::zeroed::<i32>(),
				std::mem::zeroed::<*const std::ffi::c_char>(),
				std::mem::zeroed::<*const std::ffi::c_char>()
			),
			Err(CallError::MissingCommand("vkDebugReportMessageEXT"))
		));
		assert!(matches!(
			fixture.instance.debug_report_message_ext(
				std::mem::zeroed::<vk::DebugReportFlagsEXT>(),
				std::mem::zeroed::<vk::DebugReportObjectTypeEXT>(),
				std::mem::zeroed::<u64>(),
				std::mem::zeroed::<usize>(),
				std::mem::zeroed::<i32>(),
				std::mem::zeroed::<*const std::ffi::c_char>(),
				std::mem::zeroed::<*const std::ffi::c_char>()
			),
			Err(CallError::MissingCommand("vkDebugReportMessageEXT"))
		));
	}
}

#[test]
fn debug_report_message_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }

	#[allow(clippy::too_many_arguments)]
	unsafe extern "system" fn mock(
		arg_0: vk::InstanceHandle,
		arg_1: vk::DebugReportFlagsEXT,
		arg_2: vk::DebugReportObjectTypeEXT,
		arg_3: u64,
		arg_4: usize,
		arg_5: i32,
		arg_6: *const std::ffi::c_char,
		arg_7: *const std::ffi::c_char,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::InstanceHandle::from_raw(0x1000)
					&& arg_1 == vk::DebugReportFlagsEXT::from_raw(305398016_u64 as _)
					&& arg_2 == vk::DebugReportObjectTypeEXT::from_raw(305398272_u64 as _)
					&& arg_3 == Default::default()
					&& arg_4 == Default::default()
					&& arg_5 == Default::default()
					&& std::ptr::eq(
						arg_6,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305399296)
							as *const std::ffi::c_char,
					) && std::ptr::eq(
					arg_7,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305399552)
						as *const std::ffi::c_char,
				)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkDebugReportMessageEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkDebugReportMessageEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkDebugReportMessageEXT", erased);
		let resolutions = Fixture::query_count();
		vk::debug_report_message_ext(
			&fixture.instance,
			vk::DebugReportFlagsEXT::from_raw(305398016_u64 as _),
			vk::DebugReportObjectTypeEXT::from_raw(305398272_u64 as _),
			Default::default(),
			Default::default(),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305399296) as *const std::ffi::c_char,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305399552) as *const std::ffi::c_char,
		)
		.unwrap();
		vk::Instance::debug_report_message_ext(
			&fixture.instance,
			vk::DebugReportFlagsEXT::from_raw(305398016_u64 as _),
			vk::DebugReportObjectTypeEXT::from_raw(305398272_u64 as _),
			Default::default(),
			Default::default(),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305399296) as *const std::ffi::c_char,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305399552) as *const std::ffi::c_char,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn debug_marker_set_object_name_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::DebugMarkerObjectNameInfoEXT<'_>,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::debug_marker_set_object_name_ext;
	let _: Signature = vk::Device::debug_marker_set_object_name_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::debug_marker_set_object_name_ext(
				&fixture.device,
				std::mem::zeroed::<*const vk::DebugMarkerObjectNameInfoEXT<'_>>()
			),
			Err(CallError::MissingCommand("vkDebugMarkerSetObjectNameEXT"))
		));
		assert!(matches!(
			fixture
				.device
				.debug_marker_set_object_name_ext(std::mem::zeroed::<
					*const vk::DebugMarkerObjectNameInfoEXT<'_>,
				>()),
			Err(CallError::MissingCommand("vkDebugMarkerSetObjectNameEXT"))
		));
	}
}

#[test]
fn debug_marker_set_object_name_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::DebugMarkerObjectNameInfoEXT<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::DebugMarkerObjectNameInfoEXT<'_>,
					)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkDebugMarkerSetObjectNameEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkDebugMarkerSetObjectNameEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkDebugMarkerSetObjectNameEXT", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::debug_marker_set_object_name_ext(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::DebugMarkerObjectNameInfoEXT<'_>
				),
				expected
			);
			assert_eq!(
				vk::Device::debug_marker_set_object_name_ext(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::DebugMarkerObjectNameInfoEXT<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn debug_marker_set_object_tag_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::DebugMarkerObjectTagInfoEXT<'_>,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::debug_marker_set_object_tag_ext;
	let _: Signature = vk::Device::debug_marker_set_object_tag_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::debug_marker_set_object_tag_ext(
				&fixture.device,
				std::mem::zeroed::<*const vk::DebugMarkerObjectTagInfoEXT<'_>>()
			),
			Err(CallError::MissingCommand("vkDebugMarkerSetObjectTagEXT"))
		));
		assert!(matches!(
			fixture
				.device
				.debug_marker_set_object_tag_ext(std::mem::zeroed::<
					*const vk::DebugMarkerObjectTagInfoEXT<'_>,
				>()),
			Err(CallError::MissingCommand("vkDebugMarkerSetObjectTagEXT"))
		));
	}
}

#[test]
fn debug_marker_set_object_tag_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::DebugMarkerObjectTagInfoEXT<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::DebugMarkerObjectTagInfoEXT<'_>,
					)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkDebugMarkerSetObjectTagEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkDebugMarkerSetObjectTagEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkDebugMarkerSetObjectTagEXT", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::debug_marker_set_object_tag_ext(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::DebugMarkerObjectTagInfoEXT<'_>
				),
				expected
			);
			assert_eq!(
				vk::Device::debug_marker_set_object_tag_ext(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::DebugMarkerObjectTagInfoEXT<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_debug_marker_begin_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		*const vk::DebugMarkerMarkerInfoEXT<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_debug_marker_begin_ext;
	let _: Signature = vk::Device::cmd_debug_marker_begin_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_debug_marker_begin_ext(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::DebugMarkerMarkerInfoEXT<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdDebugMarkerBeginEXT"))
		));
		assert!(matches!(
			fixture.device.cmd_debug_marker_begin_ext(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::DebugMarkerMarkerInfoEXT<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdDebugMarkerBeginEXT"))
		));
	}
}

#[test]
fn cmd_debug_marker_begin_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: *const vk::DebugMarkerMarkerInfoEXT<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::DebugMarkerMarkerInfoEXT<'_>,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdDebugMarkerBeginEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdDebugMarkerBeginEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdDebugMarkerBeginEXT", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_debug_marker_begin_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::DebugMarkerMarkerInfoEXT<'_>,
		)
		.unwrap();
		vk::Device::cmd_debug_marker_begin_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::DebugMarkerMarkerInfoEXT<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_debug_marker_end_ext_signature_and_missing_command() {
	type Signature = unsafe fn(&vk::Device, vk::CommandBuffer) -> Result<(), CallError>;
	let _: Signature = vk::cmd_debug_marker_end_ext;
	let _: Signature = vk::Device::cmd_debug_marker_end_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_debug_marker_end_ext(&fixture.device, std::mem::zeroed::<vk::CommandBuffer>()),
			Err(CallError::MissingCommand("vkCmdDebugMarkerEndEXT"))
		));
		assert!(matches!(
			fixture
				.device
				.cmd_debug_marker_end_ext(std::mem::zeroed::<vk::CommandBuffer>()),
			Err(CallError::MissingCommand("vkCmdDebugMarkerEndEXT"))
		));
	}
}

#[test]
fn cmd_debug_marker_end_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::CommandBuffer) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(MATCHED.get() && (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)));
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdDebugMarkerEndEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdDebugMarkerEndEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdDebugMarkerEndEXT", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_debug_marker_end_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
		)
		.unwrap();
		vk::Device::cmd_debug_marker_end_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_debug_marker_insert_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		*const vk::DebugMarkerMarkerInfoEXT<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_debug_marker_insert_ext;
	let _: Signature = vk::Device::cmd_debug_marker_insert_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_debug_marker_insert_ext(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::DebugMarkerMarkerInfoEXT<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdDebugMarkerInsertEXT"))
		));
		assert!(matches!(
			fixture.device.cmd_debug_marker_insert_ext(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::DebugMarkerMarkerInfoEXT<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdDebugMarkerInsertEXT"))
		));
	}
}

#[test]
fn cmd_debug_marker_insert_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: *const vk::DebugMarkerMarkerInfoEXT<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::DebugMarkerMarkerInfoEXT<'_>,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdDebugMarkerInsertEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdDebugMarkerInsertEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdDebugMarkerInsertEXT", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_debug_marker_insert_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::DebugMarkerMarkerInfoEXT<'_>,
		)
		.unwrap();
		vk::Device::cmd_debug_marker_insert_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::DebugMarkerMarkerInfoEXT<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_physical_device_external_image_format_properties_nv_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		vk::PhysicalDevice,
		vk::Format,
		vk::ImageType,
		vk::ImageTiling,
		vk::ImageUsageFlags,
		vk::ImageCreateFlags,
		vk::ExternalMemoryHandleTypeFlagsNV,
		*mut vk::ExternalImageFormatPropertiesNV,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_physical_device_external_image_format_properties_nv;
	let _: Signature = vk::Instance::get_physical_device_external_image_format_properties_nv;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_physical_device_external_image_format_properties_nv(
				&fixture.instance,
				std::mem::zeroed::<vk::PhysicalDevice>(),
				std::mem::zeroed::<vk::Format>(),
				std::mem::zeroed::<vk::ImageType>(),
				std::mem::zeroed::<vk::ImageTiling>(),
				std::mem::zeroed::<vk::ImageUsageFlags>(),
				std::mem::zeroed::<vk::ImageCreateFlags>(),
				std::mem::zeroed::<vk::ExternalMemoryHandleTypeFlagsNV>(),
				std::mem::zeroed::<*mut vk::ExternalImageFormatPropertiesNV>()
			),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceExternalImageFormatPropertiesNV"
			))
		));
		assert!(matches!(
			fixture
				.instance
				.get_physical_device_external_image_format_properties_nv(
					std::mem::zeroed::<vk::PhysicalDevice>(),
					std::mem::zeroed::<vk::Format>(),
					std::mem::zeroed::<vk::ImageType>(),
					std::mem::zeroed::<vk::ImageTiling>(),
					std::mem::zeroed::<vk::ImageUsageFlags>(),
					std::mem::zeroed::<vk::ImageCreateFlags>(),
					std::mem::zeroed::<vk::ExternalMemoryHandleTypeFlagsNV>(),
					std::mem::zeroed::<*mut vk::ExternalImageFormatPropertiesNV>()
				),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceExternalImageFormatPropertiesNV"
			))
		));
	}
}

#[test]
fn get_physical_device_external_image_format_properties_nv_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }

	#[allow(clippy::too_many_arguments)]
	unsafe extern "system" fn mock(
		arg_0: vk::PhysicalDevice,
		arg_1: vk::Format,
		arg_2: vk::ImageType,
		arg_3: vk::ImageTiling,
		arg_4: vk::ImageUsageFlags,
		arg_5: vk::ImageCreateFlags,
		arg_6: vk::ExternalMemoryHandleTypeFlagsNV,
		arg_7: *mut vk::ExternalImageFormatPropertiesNV,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::PhysicalDevice::from_raw(305397760_u64 as _)
					&& arg_1 == vk::Format::from_raw(305398016_u64 as _)
					&& arg_2 == vk::ImageType::from_raw(305398272_u64 as _)
					&& arg_3 == vk::ImageTiling::from_raw(305398528_u64 as _)
					&& arg_4 == vk::ImageUsageFlags::from_raw(305398784_u64 as _)
					&& arg_5 == vk::ImageCreateFlags::from_raw(305399040_u64 as _)
					&& arg_6 == vk::ExternalMemoryHandleTypeFlagsNV::from_raw(305399296_u64 as _)
					&& std::ptr::eq(
						arg_7,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305399552)
							as *mut vk::ExternalImageFormatPropertiesNV,
					)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(
			c"vkGetPhysicalDeviceExternalImageFormatPropertiesNV",
			erased,
		);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_physical_device_external_image_format_properties_nv(
					&fixture.instance,
					vk::PhysicalDevice::from_raw(305397760_u64 as _),
					vk::Format::from_raw(305398016_u64 as _),
					vk::ImageType::from_raw(305398272_u64 as _),
					vk::ImageTiling::from_raw(305398528_u64 as _),
					vk::ImageUsageFlags::from_raw(305398784_u64 as _),
					vk::ImageCreateFlags::from_raw(305399040_u64 as _),
					vk::ExternalMemoryHandleTypeFlagsNV::from_raw(305399296_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305399552)
						as *mut vk::ExternalImageFormatPropertiesNV
				),
				expected
			);
			assert_eq!(
				vk::Instance::get_physical_device_external_image_format_properties_nv(
					&fixture.instance,
					vk::PhysicalDevice::from_raw(305397760_u64 as _),
					vk::Format::from_raw(305398016_u64 as _),
					vk::ImageType::from_raw(305398272_u64 as _),
					vk::ImageTiling::from_raw(305398528_u64 as _),
					vk::ImageUsageFlags::from_raw(305398784_u64 as _),
					vk::ImageCreateFlags::from_raw(305399040_u64 as _),
					vk::ExternalMemoryHandleTypeFlagsNV::from_raw(305399296_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305399552)
						as *mut vk::ExternalImageFormatPropertiesNV
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[cfg(feature = "platform-win32")]
#[test]
fn get_memory_win32_handle_nv_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::DeviceMemory,
		vk::ExternalMemoryHandleTypeFlagsNV,
		*mut vk::HANDLE,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_memory_win32_handle_nv;
	let _: Signature = vk::Device::get_memory_win32_handle_nv;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_memory_win32_handle_nv(
				&fixture.device,
				std::mem::zeroed::<vk::DeviceMemory>(),
				std::mem::zeroed::<vk::ExternalMemoryHandleTypeFlagsNV>(),
				std::mem::zeroed::<*mut vk::HANDLE>()
			),
			Err(CallError::MissingCommand("vkGetMemoryWin32HandleNV"))
		));
		assert!(matches!(
			fixture.device.get_memory_win32_handle_nv(
				std::mem::zeroed::<vk::DeviceMemory>(),
				std::mem::zeroed::<vk::ExternalMemoryHandleTypeFlagsNV>(),
				std::mem::zeroed::<*mut vk::HANDLE>()
			),
			Err(CallError::MissingCommand("vkGetMemoryWin32HandleNV"))
		));
	}
}

#[cfg(feature = "platform-win32")]
#[test]
fn get_memory_win32_handle_nv_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::DeviceMemory,
		arg_2: vk::ExternalMemoryHandleTypeFlagsNV,
		arg_3: *mut vk::HANDLE,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::DeviceMemory::from_raw(305398016_u64 as _)
					&& arg_2 == vk::ExternalMemoryHandleTypeFlagsNV::from_raw(305398272_u64 as _)
					&& std::ptr::eq(
						arg_3,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::HANDLE,
					)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetMemoryWin32HandleNV = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkGetMemoryWin32HandleNV, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkGetMemoryWin32HandleNV", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_memory_win32_handle_nv(
					&fixture.device,
					vk::DeviceMemory::from_raw(305398016_u64 as _),
					vk::ExternalMemoryHandleTypeFlagsNV::from_raw(305398272_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::HANDLE
				),
				expected
			);
			assert_eq!(
				vk::Device::get_memory_win32_handle_nv(
					&fixture.device,
					vk::DeviceMemory::from_raw(305398016_u64 as _),
					vk::ExternalMemoryHandleTypeFlagsNV::from_raw(305398272_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::HANDLE
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_execute_generated_commands_nv_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		vk::Bool32,
		*const vk::GeneratedCommandsInfoNV<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_execute_generated_commands_nv;
	let _: Signature = vk::Device::cmd_execute_generated_commands_nv;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_execute_generated_commands_nv(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::Bool32>(),
				std::mem::zeroed::<*const vk::GeneratedCommandsInfoNV<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdExecuteGeneratedCommandsNV"))
		));
		assert!(matches!(
			fixture.device.cmd_execute_generated_commands_nv(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::Bool32>(),
				std::mem::zeroed::<*const vk::GeneratedCommandsInfoNV<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdExecuteGeneratedCommandsNV"))
		));
	}
}

#[test]
fn cmd_execute_generated_commands_nv_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: vk::Bool32,
		arg_2: *const vk::GeneratedCommandsInfoNV<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == 305398016_u64 as vk::Bool32
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *const vk::GeneratedCommandsInfoNV<'_>,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdExecuteGeneratedCommandsNV = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdExecuteGeneratedCommandsNV, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdExecuteGeneratedCommandsNV", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_execute_generated_commands_nv(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			305398016_u64 as vk::Bool32,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::GeneratedCommandsInfoNV<'_>,
		)
		.unwrap();
		vk::Device::cmd_execute_generated_commands_nv(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			305398016_u64 as vk::Bool32,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::GeneratedCommandsInfoNV<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_preprocess_generated_commands_nv_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		*const vk::GeneratedCommandsInfoNV<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_preprocess_generated_commands_nv;
	let _: Signature = vk::Device::cmd_preprocess_generated_commands_nv;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_preprocess_generated_commands_nv(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::GeneratedCommandsInfoNV<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkCmdPreprocessGeneratedCommandsNV"
			))
		));
		assert!(matches!(
			fixture.device.cmd_preprocess_generated_commands_nv(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::GeneratedCommandsInfoNV<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkCmdPreprocessGeneratedCommandsNV"
			))
		));
	}
}

#[test]
fn cmd_preprocess_generated_commands_nv_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: *const vk::GeneratedCommandsInfoNV<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::GeneratedCommandsInfoNV<'_>,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdPreprocessGeneratedCommandsNV = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkCmdPreprocessGeneratedCommandsNV,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdPreprocessGeneratedCommandsNV", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_preprocess_generated_commands_nv(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::GeneratedCommandsInfoNV<'_>,
		)
		.unwrap();
		vk::Device::cmd_preprocess_generated_commands_nv(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::GeneratedCommandsInfoNV<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_bind_pipeline_shader_group_nv_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		vk::PipelineBindPoint,
		vk::Pipeline,
		u32,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_bind_pipeline_shader_group_nv;
	let _: Signature = vk::Device::cmd_bind_pipeline_shader_group_nv;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_bind_pipeline_shader_group_nv(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::PipelineBindPoint>(),
				std::mem::zeroed::<vk::Pipeline>(),
				std::mem::zeroed::<u32>()
			),
			Err(CallError::MissingCommand("vkCmdBindPipelineShaderGroupNV"))
		));
		assert!(matches!(
			fixture.device.cmd_bind_pipeline_shader_group_nv(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::PipelineBindPoint>(),
				std::mem::zeroed::<vk::Pipeline>(),
				std::mem::zeroed::<u32>()
			),
			Err(CallError::MissingCommand("vkCmdBindPipelineShaderGroupNV"))
		));
	}
}

#[test]
fn cmd_bind_pipeline_shader_group_nv_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: vk::PipelineBindPoint,
		arg_2: vk::Pipeline,
		arg_3: u32,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == vk::PipelineBindPoint::from_raw(305398016_u64 as _)
					&& arg_2 == vk::Pipeline::from_raw(305398272_u64 as _)
					&& arg_3 == Default::default()),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdBindPipelineShaderGroupNV = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdBindPipelineShaderGroupNV, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdBindPipelineShaderGroupNV", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_bind_pipeline_shader_group_nv(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::PipelineBindPoint::from_raw(305398016_u64 as _),
			vk::Pipeline::from_raw(305398272_u64 as _),
			Default::default(),
		)
		.unwrap();
		vk::Device::cmd_bind_pipeline_shader_group_nv(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::PipelineBindPoint::from_raw(305398016_u64 as _),
			vk::Pipeline::from_raw(305398272_u64 as _),
			Default::default(),
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_generated_commands_memory_requirements_nv_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::GeneratedCommandsMemoryRequirementsInfoNV<'_>,
		*mut vk::MemoryRequirements2<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::get_generated_commands_memory_requirements_nv;
	let _: Signature = vk::Device::get_generated_commands_memory_requirements_nv;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_generated_commands_memory_requirements_nv(
				&fixture.device,
				std::mem::zeroed::<*const vk::GeneratedCommandsMemoryRequirementsInfoNV<'_>>(),
				std::mem::zeroed::<*mut vk::MemoryRequirements2<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetGeneratedCommandsMemoryRequirementsNV"
			))
		));
		assert!(matches!(
			fixture
				.device
				.get_generated_commands_memory_requirements_nv(
					std::mem::zeroed::<*const vk::GeneratedCommandsMemoryRequirementsInfoNV<'_>>(),
					std::mem::zeroed::<*mut vk::MemoryRequirements2<'_>>()
				),
			Err(CallError::MissingCommand(
				"vkGetGeneratedCommandsMemoryRequirementsNV"
			))
		));
	}
}

#[test]
fn get_generated_commands_memory_requirements_nv_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::GeneratedCommandsMemoryRequirementsInfoNV<'_>,
		arg_2: *mut vk::MemoryRequirements2<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::GeneratedCommandsMemoryRequirementsInfoNV<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::MemoryRequirements2<'_>,
				)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetGeneratedCommandsMemoryRequirementsNV = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetGeneratedCommandsMemoryRequirementsNV,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkGetGeneratedCommandsMemoryRequirementsNV", erased);
		let resolutions = Fixture::query_count();
		vk::get_generated_commands_memory_requirements_nv(
			&fixture.device,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::GeneratedCommandsMemoryRequirementsInfoNV<'_>,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *mut vk::MemoryRequirements2<'_>,
		)
		.unwrap();
		vk::Device::get_generated_commands_memory_requirements_nv(
			&fixture.device,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::GeneratedCommandsMemoryRequirementsInfoNV<'_>,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *mut vk::MemoryRequirements2<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn create_indirect_commands_layout_nv_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::IndirectCommandsLayoutCreateInfoNV<'_>,
		*const vk::AllocationCallbacks,
		*mut vk::IndirectCommandsLayoutNV,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::create_indirect_commands_layout_nv;
	let _: Signature = vk::Device::create_indirect_commands_layout_nv;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::create_indirect_commands_layout_nv(
				&fixture.device,
				std::mem::zeroed::<*const vk::IndirectCommandsLayoutCreateInfoNV<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::IndirectCommandsLayoutNV>()
			),
			Err(CallError::MissingCommand(
				"vkCreateIndirectCommandsLayoutNV"
			))
		));
		assert!(matches!(
			fixture.device.create_indirect_commands_layout_nv(
				std::mem::zeroed::<*const vk::IndirectCommandsLayoutCreateInfoNV<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::IndirectCommandsLayoutNV>()
			),
			Err(CallError::MissingCommand(
				"vkCreateIndirectCommandsLayoutNV"
			))
		));
	}
}

#[test]
fn create_indirect_commands_layout_nv_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::IndirectCommandsLayoutCreateInfoNV<'_>,
		arg_2: *const vk::AllocationCallbacks,
		arg_3: *mut vk::IndirectCommandsLayoutNV,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::IndirectCommandsLayoutCreateInfoNV<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
				) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::IndirectCommandsLayoutNV,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCreateIndirectCommandsLayoutNV = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkCreateIndirectCommandsLayoutNV,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkCreateIndirectCommandsLayoutNV", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::create_indirect_commands_layout_nv(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::IndirectCommandsLayoutCreateInfoNV<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::IndirectCommandsLayoutNV
				),
				expected
			);
			assert_eq!(
				vk::Device::create_indirect_commands_layout_nv(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::IndirectCommandsLayoutCreateInfoNV<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::IndirectCommandsLayoutNV
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn destroy_indirect_commands_layout_nv_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::IndirectCommandsLayoutNV,
		*const vk::AllocationCallbacks,
	) -> Result<(), CallError>;
	let _: Signature = vk::destroy_indirect_commands_layout_nv;
	let _: Signature = vk::Device::destroy_indirect_commands_layout_nv;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::destroy_indirect_commands_layout_nv(
				&fixture.device,
				std::mem::zeroed::<vk::IndirectCommandsLayoutNV>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>()
			),
			Err(CallError::MissingCommand(
				"vkDestroyIndirectCommandsLayoutNV"
			))
		));
		assert!(matches!(
			fixture.device.destroy_indirect_commands_layout_nv(
				std::mem::zeroed::<vk::IndirectCommandsLayoutNV>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>()
			),
			Err(CallError::MissingCommand(
				"vkDestroyIndirectCommandsLayoutNV"
			))
		));
	}
}

#[test]
fn destroy_indirect_commands_layout_nv_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::IndirectCommandsLayoutNV,
		arg_2: *const vk::AllocationCallbacks,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::IndirectCommandsLayoutNV::from_raw(305398016_u64 as _)
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *const vk::AllocationCallbacks,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkDestroyIndirectCommandsLayoutNV = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkDestroyIndirectCommandsLayoutNV,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkDestroyIndirectCommandsLayoutNV", erased);
		let resolutions = Fixture::query_count();
		vk::destroy_indirect_commands_layout_nv(
			&fixture.device,
			vk::IndirectCommandsLayoutNV::from_raw(305398016_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::AllocationCallbacks,
		)
		.unwrap();
		vk::Device::destroy_indirect_commands_layout_nv(
			&fixture.device,
			vk::IndirectCommandsLayoutNV::from_raw(305398016_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::AllocationCallbacks,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_execute_generated_commands_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		vk::Bool32,
		*const vk::GeneratedCommandsInfoEXT<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_execute_generated_commands_ext;
	let _: Signature = vk::Device::cmd_execute_generated_commands_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_execute_generated_commands_ext(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::Bool32>(),
				std::mem::zeroed::<*const vk::GeneratedCommandsInfoEXT<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkCmdExecuteGeneratedCommandsEXT"
			))
		));
		assert!(matches!(
			fixture.device.cmd_execute_generated_commands_ext(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::Bool32>(),
				std::mem::zeroed::<*const vk::GeneratedCommandsInfoEXT<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkCmdExecuteGeneratedCommandsEXT"
			))
		));
	}
}

#[test]
fn cmd_execute_generated_commands_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: vk::Bool32,
		arg_2: *const vk::GeneratedCommandsInfoEXT<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == 305398016_u64 as vk::Bool32
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *const vk::GeneratedCommandsInfoEXT<'_>,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdExecuteGeneratedCommandsEXT = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkCmdExecuteGeneratedCommandsEXT,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdExecuteGeneratedCommandsEXT", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_execute_generated_commands_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			305398016_u64 as vk::Bool32,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::GeneratedCommandsInfoEXT<'_>,
		)
		.unwrap();
		vk::Device::cmd_execute_generated_commands_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			305398016_u64 as vk::Bool32,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::GeneratedCommandsInfoEXT<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_preprocess_generated_commands_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		*const vk::GeneratedCommandsInfoEXT<'_>,
		vk::CommandBuffer,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_preprocess_generated_commands_ext;
	let _: Signature = vk::Device::cmd_preprocess_generated_commands_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_preprocess_generated_commands_ext(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::GeneratedCommandsInfoEXT<'_>>(),
				std::mem::zeroed::<vk::CommandBuffer>()
			),
			Err(CallError::MissingCommand(
				"vkCmdPreprocessGeneratedCommandsEXT"
			))
		));
		assert!(matches!(
			fixture.device.cmd_preprocess_generated_commands_ext(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::GeneratedCommandsInfoEXT<'_>>(),
				std::mem::zeroed::<vk::CommandBuffer>()
			),
			Err(CallError::MissingCommand(
				"vkCmdPreprocessGeneratedCommandsEXT"
			))
		));
	}
}

#[test]
fn cmd_preprocess_generated_commands_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: *const vk::GeneratedCommandsInfoEXT<'_>,
		arg_2: vk::CommandBuffer,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::GeneratedCommandsInfoEXT<'_>,
					) && arg_2 == vk::CommandBuffer::from_raw(305398272_u64 as _)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdPreprocessGeneratedCommandsEXT = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkCmdPreprocessGeneratedCommandsEXT,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdPreprocessGeneratedCommandsEXT", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_preprocess_generated_commands_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::GeneratedCommandsInfoEXT<'_>,
			vk::CommandBuffer::from_raw(305398272_u64 as _),
		)
		.unwrap();
		vk::Device::cmd_preprocess_generated_commands_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::GeneratedCommandsInfoEXT<'_>,
			vk::CommandBuffer::from_raw(305398272_u64 as _),
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_generated_commands_memory_requirements_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::GeneratedCommandsMemoryRequirementsInfoEXT<'_>,
		*mut vk::MemoryRequirements2<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::get_generated_commands_memory_requirements_ext;
	let _: Signature = vk::Device::get_generated_commands_memory_requirements_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_generated_commands_memory_requirements_ext(
				&fixture.device,
				std::mem::zeroed::<*const vk::GeneratedCommandsMemoryRequirementsInfoEXT<'_>>(),
				std::mem::zeroed::<*mut vk::MemoryRequirements2<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetGeneratedCommandsMemoryRequirementsEXT"
			))
		));
		assert!(matches!(
			fixture
				.device
				.get_generated_commands_memory_requirements_ext(
					std::mem::zeroed::<*const vk::GeneratedCommandsMemoryRequirementsInfoEXT<'_>>(),
					std::mem::zeroed::<*mut vk::MemoryRequirements2<'_>>()
				),
			Err(CallError::MissingCommand(
				"vkGetGeneratedCommandsMemoryRequirementsEXT"
			))
		));
	}
}

#[test]
fn get_generated_commands_memory_requirements_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::GeneratedCommandsMemoryRequirementsInfoEXT<'_>,
		arg_2: *mut vk::MemoryRequirements2<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::GeneratedCommandsMemoryRequirementsInfoEXT<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::MemoryRequirements2<'_>,
				)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetGeneratedCommandsMemoryRequirementsEXT = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetGeneratedCommandsMemoryRequirementsEXT,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkGetGeneratedCommandsMemoryRequirementsEXT", erased);
		let resolutions = Fixture::query_count();
		vk::get_generated_commands_memory_requirements_ext(
			&fixture.device,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::GeneratedCommandsMemoryRequirementsInfoEXT<'_>,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *mut vk::MemoryRequirements2<'_>,
		)
		.unwrap();
		vk::Device::get_generated_commands_memory_requirements_ext(
			&fixture.device,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::GeneratedCommandsMemoryRequirementsInfoEXT<'_>,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *mut vk::MemoryRequirements2<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn create_indirect_commands_layout_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::IndirectCommandsLayoutCreateInfoEXT<'_>,
		*const vk::AllocationCallbacks,
		*mut vk::IndirectCommandsLayoutEXT,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::create_indirect_commands_layout_ext;
	let _: Signature = vk::Device::create_indirect_commands_layout_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::create_indirect_commands_layout_ext(
				&fixture.device,
				std::mem::zeroed::<*const vk::IndirectCommandsLayoutCreateInfoEXT<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::IndirectCommandsLayoutEXT>()
			),
			Err(CallError::MissingCommand(
				"vkCreateIndirectCommandsLayoutEXT"
			))
		));
		assert!(matches!(
			fixture.device.create_indirect_commands_layout_ext(
				std::mem::zeroed::<*const vk::IndirectCommandsLayoutCreateInfoEXT<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::IndirectCommandsLayoutEXT>()
			),
			Err(CallError::MissingCommand(
				"vkCreateIndirectCommandsLayoutEXT"
			))
		));
	}
}

#[test]
fn create_indirect_commands_layout_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::IndirectCommandsLayoutCreateInfoEXT<'_>,
		arg_2: *const vk::AllocationCallbacks,
		arg_3: *mut vk::IndirectCommandsLayoutEXT,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::IndirectCommandsLayoutCreateInfoEXT<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
				) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::IndirectCommandsLayoutEXT,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCreateIndirectCommandsLayoutEXT = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkCreateIndirectCommandsLayoutEXT,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkCreateIndirectCommandsLayoutEXT", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::create_indirect_commands_layout_ext(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::IndirectCommandsLayoutCreateInfoEXT<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::IndirectCommandsLayoutEXT
				),
				expected
			);
			assert_eq!(
				vk::Device::create_indirect_commands_layout_ext(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::IndirectCommandsLayoutCreateInfoEXT<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::IndirectCommandsLayoutEXT
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn destroy_indirect_commands_layout_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::IndirectCommandsLayoutEXT,
		*const vk::AllocationCallbacks,
	) -> Result<(), CallError>;
	let _: Signature = vk::destroy_indirect_commands_layout_ext;
	let _: Signature = vk::Device::destroy_indirect_commands_layout_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::destroy_indirect_commands_layout_ext(
				&fixture.device,
				std::mem::zeroed::<vk::IndirectCommandsLayoutEXT>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>()
			),
			Err(CallError::MissingCommand(
				"vkDestroyIndirectCommandsLayoutEXT"
			))
		));
		assert!(matches!(
			fixture.device.destroy_indirect_commands_layout_ext(
				std::mem::zeroed::<vk::IndirectCommandsLayoutEXT>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>()
			),
			Err(CallError::MissingCommand(
				"vkDestroyIndirectCommandsLayoutEXT"
			))
		));
	}
}

#[test]
fn destroy_indirect_commands_layout_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::IndirectCommandsLayoutEXT,
		arg_2: *const vk::AllocationCallbacks,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::IndirectCommandsLayoutEXT::from_raw(305398016_u64 as _)
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *const vk::AllocationCallbacks,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkDestroyIndirectCommandsLayoutEXT = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkDestroyIndirectCommandsLayoutEXT,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkDestroyIndirectCommandsLayoutEXT", erased);
		let resolutions = Fixture::query_count();
		vk::destroy_indirect_commands_layout_ext(
			&fixture.device,
			vk::IndirectCommandsLayoutEXT::from_raw(305398016_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::AllocationCallbacks,
		)
		.unwrap();
		vk::Device::destroy_indirect_commands_layout_ext(
			&fixture.device,
			vk::IndirectCommandsLayoutEXT::from_raw(305398016_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::AllocationCallbacks,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn create_indirect_execution_set_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::IndirectExecutionSetCreateInfoEXT<'_>,
		*const vk::AllocationCallbacks,
		*mut vk::IndirectExecutionSetEXT,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::create_indirect_execution_set_ext;
	let _: Signature = vk::Device::create_indirect_execution_set_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::create_indirect_execution_set_ext(
				&fixture.device,
				std::mem::zeroed::<*const vk::IndirectExecutionSetCreateInfoEXT<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::IndirectExecutionSetEXT>()
			),
			Err(CallError::MissingCommand("vkCreateIndirectExecutionSetEXT"))
		));
		assert!(matches!(
			fixture.device.create_indirect_execution_set_ext(
				std::mem::zeroed::<*const vk::IndirectExecutionSetCreateInfoEXT<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::IndirectExecutionSetEXT>()
			),
			Err(CallError::MissingCommand("vkCreateIndirectExecutionSetEXT"))
		));
	}
}

#[test]
fn create_indirect_execution_set_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::IndirectExecutionSetCreateInfoEXT<'_>,
		arg_2: *const vk::AllocationCallbacks,
		arg_3: *mut vk::IndirectExecutionSetEXT,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::IndirectExecutionSetCreateInfoEXT<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
				) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::IndirectExecutionSetEXT,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCreateIndirectExecutionSetEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCreateIndirectExecutionSetEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCreateIndirectExecutionSetEXT", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::create_indirect_execution_set_ext(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::IndirectExecutionSetCreateInfoEXT<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::IndirectExecutionSetEXT
				),
				expected
			);
			assert_eq!(
				vk::Device::create_indirect_execution_set_ext(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::IndirectExecutionSetCreateInfoEXT<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::IndirectExecutionSetEXT
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn destroy_indirect_execution_set_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::IndirectExecutionSetEXT,
		*const vk::AllocationCallbacks,
	) -> Result<(), CallError>;
	let _: Signature = vk::destroy_indirect_execution_set_ext;
	let _: Signature = vk::Device::destroy_indirect_execution_set_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::destroy_indirect_execution_set_ext(
				&fixture.device,
				std::mem::zeroed::<vk::IndirectExecutionSetEXT>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>()
			),
			Err(CallError::MissingCommand(
				"vkDestroyIndirectExecutionSetEXT"
			))
		));
		assert!(matches!(
			fixture.device.destroy_indirect_execution_set_ext(
				std::mem::zeroed::<vk::IndirectExecutionSetEXT>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>()
			),
			Err(CallError::MissingCommand(
				"vkDestroyIndirectExecutionSetEXT"
			))
		));
	}
}

#[test]
fn destroy_indirect_execution_set_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::IndirectExecutionSetEXT,
		arg_2: *const vk::AllocationCallbacks,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::IndirectExecutionSetEXT::from_raw(305398016_u64 as _)
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *const vk::AllocationCallbacks,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkDestroyIndirectExecutionSetEXT = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkDestroyIndirectExecutionSetEXT,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkDestroyIndirectExecutionSetEXT", erased);
		let resolutions = Fixture::query_count();
		vk::destroy_indirect_execution_set_ext(
			&fixture.device,
			vk::IndirectExecutionSetEXT::from_raw(305398016_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::AllocationCallbacks,
		)
		.unwrap();
		vk::Device::destroy_indirect_execution_set_ext(
			&fixture.device,
			vk::IndirectExecutionSetEXT::from_raw(305398016_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::AllocationCallbacks,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn update_indirect_execution_set_pipeline_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::IndirectExecutionSetEXT,
		u32,
		*const vk::WriteIndirectExecutionSetPipelineEXT<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::update_indirect_execution_set_pipeline_ext;
	let _: Signature = vk::Device::update_indirect_execution_set_pipeline_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::update_indirect_execution_set_pipeline_ext(
				&fixture.device,
				std::mem::zeroed::<vk::IndirectExecutionSetEXT>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::WriteIndirectExecutionSetPipelineEXT<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkUpdateIndirectExecutionSetPipelineEXT"
			))
		));
		assert!(matches!(
			fixture.device.update_indirect_execution_set_pipeline_ext(
				std::mem::zeroed::<vk::IndirectExecutionSetEXT>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::WriteIndirectExecutionSetPipelineEXT<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkUpdateIndirectExecutionSetPipelineEXT"
			))
		));
	}
}

#[test]
fn update_indirect_execution_set_pipeline_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::IndirectExecutionSetEXT,
		arg_2: u32,
		arg_3: *const vk::WriteIndirectExecutionSetPipelineEXT<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::IndirectExecutionSetEXT::from_raw(305398016_u64 as _)
					&& arg_2 == Default::default()
					&& std::ptr::eq(
						arg_3,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
							as *const vk::WriteIndirectExecutionSetPipelineEXT<'_>,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkUpdateIndirectExecutionSetPipelineEXT = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkUpdateIndirectExecutionSetPipelineEXT,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkUpdateIndirectExecutionSetPipelineEXT", erased);
		let resolutions = Fixture::query_count();
		vk::update_indirect_execution_set_pipeline_ext(
			&fixture.device,
			vk::IndirectExecutionSetEXT::from_raw(305398016_u64 as _),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
				as *const vk::WriteIndirectExecutionSetPipelineEXT<'_>,
		)
		.unwrap();
		vk::Device::update_indirect_execution_set_pipeline_ext(
			&fixture.device,
			vk::IndirectExecutionSetEXT::from_raw(305398016_u64 as _),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
				as *const vk::WriteIndirectExecutionSetPipelineEXT<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn update_indirect_execution_set_shader_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::IndirectExecutionSetEXT,
		u32,
		*const vk::WriteIndirectExecutionSetShaderEXT<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::update_indirect_execution_set_shader_ext;
	let _: Signature = vk::Device::update_indirect_execution_set_shader_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::update_indirect_execution_set_shader_ext(
				&fixture.device,
				std::mem::zeroed::<vk::IndirectExecutionSetEXT>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::WriteIndirectExecutionSetShaderEXT<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkUpdateIndirectExecutionSetShaderEXT"
			))
		));
		assert!(matches!(
			fixture.device.update_indirect_execution_set_shader_ext(
				std::mem::zeroed::<vk::IndirectExecutionSetEXT>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::WriteIndirectExecutionSetShaderEXT<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkUpdateIndirectExecutionSetShaderEXT"
			))
		));
	}
}

#[test]
fn update_indirect_execution_set_shader_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::IndirectExecutionSetEXT,
		arg_2: u32,
		arg_3: *const vk::WriteIndirectExecutionSetShaderEXT<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::IndirectExecutionSetEXT::from_raw(305398016_u64 as _)
					&& arg_2 == Default::default()
					&& std::ptr::eq(
						arg_3,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
							as *const vk::WriteIndirectExecutionSetShaderEXT<'_>,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkUpdateIndirectExecutionSetShaderEXT = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkUpdateIndirectExecutionSetShaderEXT,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkUpdateIndirectExecutionSetShaderEXT", erased);
		let resolutions = Fixture::query_count();
		vk::update_indirect_execution_set_shader_ext(
			&fixture.device,
			vk::IndirectExecutionSetEXT::from_raw(305398016_u64 as _),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
				as *const vk::WriteIndirectExecutionSetShaderEXT<'_>,
		)
		.unwrap();
		vk::Device::update_indirect_execution_set_shader_ext(
			&fixture.device,
			vk::IndirectExecutionSetEXT::from_raw(305398016_u64 as _),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
				as *const vk::WriteIndirectExecutionSetShaderEXT<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_physical_device_features2_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		vk::PhysicalDevice,
		&mut vk::PhysicalDeviceFeatures2<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::get_physical_device_features2;
	let _: Signature = vk::Instance::get_physical_device_features2;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_physical_device_features2(
				&fixture.instance,
				Default::default(),
				&mut std::mem::zeroed::<vk::PhysicalDeviceFeatures2<'_>>()
			),
			Err(CallError::MissingCommand("vkGetPhysicalDeviceFeatures2"))
		));
		assert!(matches!(
			fixture.instance.get_physical_device_features2(
				Default::default(),
				&mut std::mem::zeroed::<vk::PhysicalDeviceFeatures2<'_>>()
			),
			Err(CallError::MissingCommand("vkGetPhysicalDeviceFeatures2"))
		));
	}
}

#[test]
fn get_physical_device_features2_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		vk::PhysicalDevice,
		&mut vk::PhysicalDeviceFeatures2<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::get_physical_device_features2_khr;
	let _: Signature = vk::Instance::get_physical_device_features2_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_physical_device_features2_khr(
				&fixture.instance,
				Default::default(),
				&mut std::mem::zeroed::<vk::PhysicalDeviceFeatures2<'_>>()
			),
			Err(CallError::MissingCommand("vkGetPhysicalDeviceFeatures2KHR"))
		));
		assert!(matches!(
			fixture.instance.get_physical_device_features2_khr(
				Default::default(),
				&mut std::mem::zeroed::<vk::PhysicalDeviceFeatures2<'_>>()
			),
			Err(CallError::MissingCommand("vkGetPhysicalDeviceFeatures2KHR"))
		));
	}
}

#[test]
fn get_physical_device_properties2_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		vk::PhysicalDevice,
		&mut vk::PhysicalDeviceProperties2<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::get_physical_device_properties2;
	let _: Signature = vk::Instance::get_physical_device_properties2;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_physical_device_properties2(
				&fixture.instance,
				Default::default(),
				&mut std::mem::zeroed::<vk::PhysicalDeviceProperties2<'_>>()
			),
			Err(CallError::MissingCommand("vkGetPhysicalDeviceProperties2"))
		));
		assert!(matches!(
			fixture.instance.get_physical_device_properties2(
				Default::default(),
				&mut std::mem::zeroed::<vk::PhysicalDeviceProperties2<'_>>()
			),
			Err(CallError::MissingCommand("vkGetPhysicalDeviceProperties2"))
		));
	}
}

#[test]
fn get_physical_device_properties2_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		vk::PhysicalDevice,
		&mut vk::PhysicalDeviceProperties2<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::get_physical_device_properties2_khr;
	let _: Signature = vk::Instance::get_physical_device_properties2_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_physical_device_properties2_khr(
				&fixture.instance,
				Default::default(),
				&mut std::mem::zeroed::<vk::PhysicalDeviceProperties2<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceProperties2KHR"
			))
		));
		assert!(matches!(
			fixture.instance.get_physical_device_properties2_khr(
				Default::default(),
				&mut std::mem::zeroed::<vk::PhysicalDeviceProperties2<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceProperties2KHR"
			))
		));
	}
}

#[test]
fn get_physical_device_format_properties2_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		vk::PhysicalDevice,
		vk::Format,
		&mut vk::FormatProperties2<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::get_physical_device_format_properties2;
	let _: Signature = vk::Instance::get_physical_device_format_properties2;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_physical_device_format_properties2(
				&fixture.instance,
				Default::default(),
				Default::default(),
				&mut std::mem::zeroed::<vk::FormatProperties2<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceFormatProperties2"
			))
		));
		assert!(matches!(
			fixture.instance.get_physical_device_format_properties2(
				Default::default(),
				Default::default(),
				&mut std::mem::zeroed::<vk::FormatProperties2<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceFormatProperties2"
			))
		));
	}
}

#[test]
fn get_physical_device_format_properties2_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		vk::PhysicalDevice,
		vk::Format,
		&mut vk::FormatProperties2<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::get_physical_device_format_properties2_khr;
	let _: Signature = vk::Instance::get_physical_device_format_properties2_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_physical_device_format_properties2_khr(
				&fixture.instance,
				Default::default(),
				Default::default(),
				&mut std::mem::zeroed::<vk::FormatProperties2<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceFormatProperties2KHR"
			))
		));
		assert!(matches!(
			fixture.instance.get_physical_device_format_properties2_khr(
				Default::default(),
				Default::default(),
				&mut std::mem::zeroed::<vk::FormatProperties2<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceFormatProperties2KHR"
			))
		));
	}
}

#[test]
fn get_physical_device_image_format_properties2_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		vk::PhysicalDevice,
		&vk::PhysicalDeviceImageFormatInfo2<'_>,
		&mut vk::ImageFormatProperties2<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::get_physical_device_image_format_properties2;
	let _: Signature = vk::Instance::get_physical_device_image_format_properties2;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_physical_device_image_format_properties2(
				&fixture.instance,
				Default::default(),
				&std::mem::zeroed::<vk::PhysicalDeviceImageFormatInfo2<'_>>(),
				&mut std::mem::zeroed::<vk::ImageFormatProperties2<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceImageFormatProperties2"
			))
		));
		assert!(matches!(
			fixture
				.instance
				.get_physical_device_image_format_properties2(
					Default::default(),
					&std::mem::zeroed::<vk::PhysicalDeviceImageFormatInfo2<'_>>(),
					&mut std::mem::zeroed::<vk::ImageFormatProperties2<'_>>()
				),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceImageFormatProperties2"
			))
		));
	}
}

#[test]
fn get_physical_device_image_format_properties2_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		vk::PhysicalDevice,
		&vk::PhysicalDeviceImageFormatInfo2<'_>,
		&mut vk::ImageFormatProperties2<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::get_physical_device_image_format_properties2_khr;
	let _: Signature = vk::Instance::get_physical_device_image_format_properties2_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_physical_device_image_format_properties2_khr(
				&fixture.instance,
				Default::default(),
				&std::mem::zeroed::<vk::PhysicalDeviceImageFormatInfo2<'_>>(),
				&mut std::mem::zeroed::<vk::ImageFormatProperties2<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceImageFormatProperties2KHR"
			))
		));
		assert!(matches!(
			fixture
				.instance
				.get_physical_device_image_format_properties2_khr(
					Default::default(),
					&std::mem::zeroed::<vk::PhysicalDeviceImageFormatInfo2<'_>>(),
					&mut std::mem::zeroed::<vk::ImageFormatProperties2<'_>>()
				),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceImageFormatProperties2KHR"
			))
		));
	}
}

#[test]
fn get_physical_device_queue_family_properties2_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		vk::PhysicalDevice,
		&mut u32,
		Option<&mut [vk::QueueFamilyProperties2<'_>]>,
	) -> Result<(), CallError>;
	let _: Signature = vk::get_physical_device_queue_family_properties2;
	let _: Signature = vk::Instance::get_physical_device_queue_family_properties2;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_physical_device_queue_family_properties2(
				&fixture.instance,
				Default::default(),
				&mut 0,
				None
			),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceQueueFamilyProperties2"
			))
		));
		assert!(matches!(
			fixture
				.instance
				.get_physical_device_queue_family_properties2(Default::default(), &mut 0, None),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceQueueFamilyProperties2"
			))
		));
	}
}

#[test]
fn get_physical_device_queue_family_properties2_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		vk::PhysicalDevice,
		&mut u32,
		Option<&mut [vk::QueueFamilyProperties2<'_>]>,
	) -> Result<(), CallError>;
	let _: Signature = vk::get_physical_device_queue_family_properties2_khr;
	let _: Signature = vk::Instance::get_physical_device_queue_family_properties2_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_physical_device_queue_family_properties2_khr(
				&fixture.instance,
				Default::default(),
				&mut 0,
				None
			),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceQueueFamilyProperties2KHR"
			))
		));
		assert!(matches!(
			fixture
				.instance
				.get_physical_device_queue_family_properties2_khr(Default::default(), &mut 0, None),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceQueueFamilyProperties2KHR"
			))
		));
	}
}

#[test]
fn get_physical_device_memory_properties2_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		vk::PhysicalDevice,
		&mut vk::PhysicalDeviceMemoryProperties2<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::get_physical_device_memory_properties2;
	let _: Signature = vk::Instance::get_physical_device_memory_properties2;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_physical_device_memory_properties2(
				&fixture.instance,
				Default::default(),
				&mut std::mem::zeroed::<vk::PhysicalDeviceMemoryProperties2<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceMemoryProperties2"
			))
		));
		assert!(matches!(
			fixture.instance.get_physical_device_memory_properties2(
				Default::default(),
				&mut std::mem::zeroed::<vk::PhysicalDeviceMemoryProperties2<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceMemoryProperties2"
			))
		));
	}
}

#[test]
fn get_physical_device_memory_properties2_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		vk::PhysicalDevice,
		&mut vk::PhysicalDeviceMemoryProperties2<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::get_physical_device_memory_properties2_khr;
	let _: Signature = vk::Instance::get_physical_device_memory_properties2_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_physical_device_memory_properties2_khr(
				&fixture.instance,
				Default::default(),
				&mut std::mem::zeroed::<vk::PhysicalDeviceMemoryProperties2<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceMemoryProperties2KHR"
			))
		));
		assert!(matches!(
			fixture.instance.get_physical_device_memory_properties2_khr(
				Default::default(),
				&mut std::mem::zeroed::<vk::PhysicalDeviceMemoryProperties2<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceMemoryProperties2KHR"
			))
		));
	}
}

#[test]
fn get_physical_device_sparse_image_format_properties2_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		vk::PhysicalDevice,
		&vk::PhysicalDeviceSparseImageFormatInfo2<'_>,
		&mut u32,
		Option<&mut [vk::SparseImageFormatProperties2<'_>]>,
	) -> Result<(), CallError>;
	let _: Signature = vk::get_physical_device_sparse_image_format_properties2;
	let _: Signature = vk::Instance::get_physical_device_sparse_image_format_properties2;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_physical_device_sparse_image_format_properties2(
				&fixture.instance,
				Default::default(),
				&std::mem::zeroed::<vk::PhysicalDeviceSparseImageFormatInfo2<'_>>(),
				&mut 0,
				None
			),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceSparseImageFormatProperties2"
			))
		));
		assert!(matches!(
			fixture
				.instance
				.get_physical_device_sparse_image_format_properties2(
					Default::default(),
					&std::mem::zeroed::<vk::PhysicalDeviceSparseImageFormatInfo2<'_>>(),
					&mut 0,
					None
				),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceSparseImageFormatProperties2"
			))
		));
	}
}

#[test]
fn get_physical_device_sparse_image_format_properties2_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		vk::PhysicalDevice,
		&vk::PhysicalDeviceSparseImageFormatInfo2<'_>,
		&mut u32,
		Option<&mut [vk::SparseImageFormatProperties2<'_>]>,
	) -> Result<(), CallError>;
	let _: Signature = vk::get_physical_device_sparse_image_format_properties2_khr;
	let _: Signature = vk::Instance::get_physical_device_sparse_image_format_properties2_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_physical_device_sparse_image_format_properties2_khr(
				&fixture.instance,
				Default::default(),
				&std::mem::zeroed::<vk::PhysicalDeviceSparseImageFormatInfo2<'_>>(),
				&mut 0,
				None
			),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceSparseImageFormatProperties2KHR"
			))
		));
		assert!(matches!(
			fixture
				.instance
				.get_physical_device_sparse_image_format_properties2_khr(
					Default::default(),
					&std::mem::zeroed::<vk::PhysicalDeviceSparseImageFormatInfo2<'_>>(),
					&mut 0,
					None
				),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceSparseImageFormatProperties2KHR"
			))
		));
	}
}

#[test]
fn cmd_push_descriptor_set_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		vk::PipelineBindPoint,
		vk::PipelineLayout,
		u32,
		u32,
		*const vk::WriteDescriptorSet<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_push_descriptor_set;
	let _: Signature = vk::Device::cmd_push_descriptor_set;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_push_descriptor_set(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::PipelineBindPoint>(),
				std::mem::zeroed::<vk::PipelineLayout>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::WriteDescriptorSet<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdPushDescriptorSet"))
		));
		assert!(matches!(
			fixture.device.cmd_push_descriptor_set(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::PipelineBindPoint>(),
				std::mem::zeroed::<vk::PipelineLayout>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::WriteDescriptorSet<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdPushDescriptorSet"))
		));
	}
}

#[test]
fn cmd_push_descriptor_set_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: vk::PipelineBindPoint,
		arg_2: vk::PipelineLayout,
		arg_3: u32,
		arg_4: u32,
		arg_5: *const vk::WriteDescriptorSet<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == vk::PipelineBindPoint::from_raw(305398016_u64 as _)
					&& arg_2 == vk::PipelineLayout::from_raw(305398272_u64 as _)
					&& arg_3 == Default::default()
					&& arg_4 == Default::default()
					&& std::ptr::eq(
						arg_5,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305399040)
							as *const vk::WriteDescriptorSet<'_>,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdPushDescriptorSet = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdPushDescriptorSet, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdPushDescriptorSet", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_push_descriptor_set(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::PipelineBindPoint::from_raw(305398016_u64 as _),
			vk::PipelineLayout::from_raw(305398272_u64 as _),
			Default::default(),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305399040)
				as *const vk::WriteDescriptorSet<'_>,
		)
		.unwrap();
		vk::Device::cmd_push_descriptor_set(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::PipelineBindPoint::from_raw(305398016_u64 as _),
			vk::PipelineLayout::from_raw(305398272_u64 as _),
			Default::default(),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305399040)
				as *const vk::WriteDescriptorSet<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_push_descriptor_set_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		vk::PipelineBindPoint,
		vk::PipelineLayout,
		u32,
		u32,
		*const vk::WriteDescriptorSet<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_push_descriptor_set_khr;
	let _: Signature = vk::Device::cmd_push_descriptor_set_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_push_descriptor_set_khr(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::PipelineBindPoint>(),
				std::mem::zeroed::<vk::PipelineLayout>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::WriteDescriptorSet<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdPushDescriptorSetKHR"))
		));
		assert!(matches!(
			fixture.device.cmd_push_descriptor_set_khr(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::PipelineBindPoint>(),
				std::mem::zeroed::<vk::PipelineLayout>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::WriteDescriptorSet<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdPushDescriptorSetKHR"))
		));
	}
}

#[test]
fn cmd_push_descriptor_set_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: vk::PipelineBindPoint,
		arg_2: vk::PipelineLayout,
		arg_3: u32,
		arg_4: u32,
		arg_5: *const vk::WriteDescriptorSet<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == vk::PipelineBindPoint::from_raw(305398016_u64 as _)
					&& arg_2 == vk::PipelineLayout::from_raw(305398272_u64 as _)
					&& arg_3 == Default::default()
					&& arg_4 == Default::default()
					&& std::ptr::eq(
						arg_5,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305399040)
							as *const vk::WriteDescriptorSet<'_>,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdPushDescriptorSetKHR = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdPushDescriptorSetKHR, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdPushDescriptorSetKHR", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_push_descriptor_set_khr(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::PipelineBindPoint::from_raw(305398016_u64 as _),
			vk::PipelineLayout::from_raw(305398272_u64 as _),
			Default::default(),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305399040)
				as *const vk::WriteDescriptorSet<'_>,
		)
		.unwrap();
		vk::Device::cmd_push_descriptor_set_khr(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::PipelineBindPoint::from_raw(305398016_u64 as _),
			vk::PipelineLayout::from_raw(305398272_u64 as _),
			Default::default(),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305399040)
				as *const vk::WriteDescriptorSet<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn trim_command_pool_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, vk::CommandPool, vk::CommandPoolTrimFlags) -> Result<(), CallError>;
	let _: Signature = vk::trim_command_pool;
	let _: Signature = vk::Device::trim_command_pool;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::trim_command_pool(&fixture.device, Default::default(), Default::default()),
			Err(CallError::MissingCommand("vkTrimCommandPool"))
		));
		assert!(matches!(
			fixture
				.device
				.trim_command_pool(Default::default(), Default::default()),
			Err(CallError::MissingCommand("vkTrimCommandPool"))
		));
	}
}

#[test]
fn trim_command_pool_khr_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, vk::CommandPool, vk::CommandPoolTrimFlags) -> Result<(), CallError>;
	let _: Signature = vk::trim_command_pool_khr;
	let _: Signature = vk::Device::trim_command_pool_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::trim_command_pool_khr(&fixture.device, Default::default(), Default::default()),
			Err(CallError::MissingCommand("vkTrimCommandPoolKHR"))
		));
		assert!(matches!(
			fixture
				.device
				.trim_command_pool_khr(Default::default(), Default::default()),
			Err(CallError::MissingCommand("vkTrimCommandPoolKHR"))
		));
	}
}

#[test]
fn get_physical_device_external_buffer_properties_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		vk::PhysicalDevice,
		&vk::PhysicalDeviceExternalBufferInfo<'_>,
		&mut vk::ExternalBufferProperties<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::get_physical_device_external_buffer_properties;
	let _: Signature = vk::Instance::get_physical_device_external_buffer_properties;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_physical_device_external_buffer_properties(
				&fixture.instance,
				Default::default(),
				&std::mem::zeroed::<vk::PhysicalDeviceExternalBufferInfo<'_>>(),
				&mut std::mem::zeroed::<vk::ExternalBufferProperties<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceExternalBufferProperties"
			))
		));
		assert!(matches!(
			fixture
				.instance
				.get_physical_device_external_buffer_properties(
					Default::default(),
					&std::mem::zeroed::<vk::PhysicalDeviceExternalBufferInfo<'_>>(),
					&mut std::mem::zeroed::<vk::ExternalBufferProperties<'_>>()
				),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceExternalBufferProperties"
			))
		));
	}
}

#[test]
fn get_physical_device_external_buffer_properties_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		vk::PhysicalDevice,
		&vk::PhysicalDeviceExternalBufferInfo<'_>,
		&mut vk::ExternalBufferProperties<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::get_physical_device_external_buffer_properties_khr;
	let _: Signature = vk::Instance::get_physical_device_external_buffer_properties_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_physical_device_external_buffer_properties_khr(
				&fixture.instance,
				Default::default(),
				&std::mem::zeroed::<vk::PhysicalDeviceExternalBufferInfo<'_>>(),
				&mut std::mem::zeroed::<vk::ExternalBufferProperties<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceExternalBufferPropertiesKHR"
			))
		));
		assert!(matches!(
			fixture
				.instance
				.get_physical_device_external_buffer_properties_khr(
					Default::default(),
					&std::mem::zeroed::<vk::PhysicalDeviceExternalBufferInfo<'_>>(),
					&mut std::mem::zeroed::<vk::ExternalBufferProperties<'_>>()
				),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceExternalBufferPropertiesKHR"
			))
		));
	}
}

#[cfg(feature = "platform-win32")]
#[test]
fn get_memory_win32_handle_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::MemoryGetWin32HandleInfoKHR<'_>,
		*mut vk::HANDLE,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_memory_win32_handle_khr;
	let _: Signature = vk::Device::get_memory_win32_handle_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_memory_win32_handle_khr(
				&fixture.device,
				std::mem::zeroed::<*const vk::MemoryGetWin32HandleInfoKHR<'_>>(),
				std::mem::zeroed::<*mut vk::HANDLE>()
			),
			Err(CallError::MissingCommand("vkGetMemoryWin32HandleKHR"))
		));
		assert!(matches!(
			fixture.device.get_memory_win32_handle_khr(
				std::mem::zeroed::<*const vk::MemoryGetWin32HandleInfoKHR<'_>>(),
				std::mem::zeroed::<*mut vk::HANDLE>()
			),
			Err(CallError::MissingCommand("vkGetMemoryWin32HandleKHR"))
		));
	}
}

#[cfg(feature = "platform-win32")]
#[test]
fn get_memory_win32_handle_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::MemoryGetWin32HandleInfoKHR<'_>,
		arg_2: *mut vk::HANDLE,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::MemoryGetWin32HandleInfoKHR<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut vk::HANDLE,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetMemoryWin32HandleKHR = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkGetMemoryWin32HandleKHR, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkGetMemoryWin32HandleKHR", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_memory_win32_handle_khr(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::MemoryGetWin32HandleInfoKHR<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut vk::HANDLE
				),
				expected
			);
			assert_eq!(
				vk::Device::get_memory_win32_handle_khr(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::MemoryGetWin32HandleInfoKHR<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut vk::HANDLE
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[cfg(feature = "platform-win32")]
#[test]
fn get_memory_win32_handle_properties_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::ExternalMemoryHandleTypeFlagBits,
		vk::HANDLE,
		*mut vk::MemoryWin32HandlePropertiesKHR<'_>,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_memory_win32_handle_properties_khr;
	let _: Signature = vk::Device::get_memory_win32_handle_properties_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_memory_win32_handle_properties_khr(
				&fixture.device,
				std::mem::zeroed::<vk::ExternalMemoryHandleTypeFlagBits>(),
				std::mem::zeroed::<vk::HANDLE>(),
				std::mem::zeroed::<*mut vk::MemoryWin32HandlePropertiesKHR<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetMemoryWin32HandlePropertiesKHR"
			))
		));
		assert!(matches!(
			fixture.device.get_memory_win32_handle_properties_khr(
				std::mem::zeroed::<vk::ExternalMemoryHandleTypeFlagBits>(),
				std::mem::zeroed::<vk::HANDLE>(),
				std::mem::zeroed::<*mut vk::MemoryWin32HandlePropertiesKHR<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetMemoryWin32HandlePropertiesKHR"
			))
		));
	}
}

#[cfg(feature = "platform-win32")]
#[test]
fn get_memory_win32_handle_properties_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::ExternalMemoryHandleTypeFlagBits,
		arg_2: vk::HANDLE,
		arg_3: *mut vk::MemoryWin32HandlePropertiesKHR<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::ExternalMemoryHandleTypeFlagBits::from_raw(305398016_u64 as _)
					&& arg_2 == Default::default()
					&& std::ptr::eq(
						arg_3,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
							as *mut vk::MemoryWin32HandlePropertiesKHR<'_>,
					)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetMemoryWin32HandlePropertiesKHR = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetMemoryWin32HandlePropertiesKHR,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkGetMemoryWin32HandlePropertiesKHR", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_memory_win32_handle_properties_khr(
					&fixture.device,
					vk::ExternalMemoryHandleTypeFlagBits::from_raw(305398016_u64 as _),
					Default::default(),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::MemoryWin32HandlePropertiesKHR<'_>
				),
				expected
			);
			assert_eq!(
				vk::Device::get_memory_win32_handle_properties_khr(
					&fixture.device,
					vk::ExternalMemoryHandleTypeFlagBits::from_raw(305398016_u64 as _),
					Default::default(),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::MemoryWin32HandlePropertiesKHR<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_memory_fd_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::MemoryGetFdInfoKHR<'_>,
		*mut i32,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_memory_fd_khr;
	let _: Signature = vk::Device::get_memory_fd_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_memory_fd_khr(
				&fixture.device,
				std::mem::zeroed::<*const vk::MemoryGetFdInfoKHR<'_>>(),
				std::mem::zeroed::<*mut i32>()
			),
			Err(CallError::MissingCommand("vkGetMemoryFdKHR"))
		));
		assert!(matches!(
			fixture.device.get_memory_fd_khr(
				std::mem::zeroed::<*const vk::MemoryGetFdInfoKHR<'_>>(),
				std::mem::zeroed::<*mut i32>()
			),
			Err(CallError::MissingCommand("vkGetMemoryFdKHR"))
		));
	}
}

#[test]
fn get_memory_fd_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::MemoryGetFdInfoKHR<'_>,
		arg_2: *mut i32,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::MemoryGetFdInfoKHR<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut i32,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetMemoryFdKHR = Some(mock);
		let erased = std::mem::transmute::<vk::PFN_vkGetMemoryFdKHR, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkGetMemoryFdKHR", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_memory_fd_khr(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::MemoryGetFdInfoKHR<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut i32
				),
				expected
			);
			assert_eq!(
				vk::Device::get_memory_fd_khr(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::MemoryGetFdInfoKHR<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut i32
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_memory_fd_properties_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::ExternalMemoryHandleTypeFlagBits,
		i32,
		*mut vk::MemoryFdPropertiesKHR<'_>,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_memory_fd_properties_khr;
	let _: Signature = vk::Device::get_memory_fd_properties_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_memory_fd_properties_khr(
				&fixture.device,
				std::mem::zeroed::<vk::ExternalMemoryHandleTypeFlagBits>(),
				std::mem::zeroed::<i32>(),
				std::mem::zeroed::<*mut vk::MemoryFdPropertiesKHR<'_>>()
			),
			Err(CallError::MissingCommand("vkGetMemoryFdPropertiesKHR"))
		));
		assert!(matches!(
			fixture.device.get_memory_fd_properties_khr(
				std::mem::zeroed::<vk::ExternalMemoryHandleTypeFlagBits>(),
				std::mem::zeroed::<i32>(),
				std::mem::zeroed::<*mut vk::MemoryFdPropertiesKHR<'_>>()
			),
			Err(CallError::MissingCommand("vkGetMemoryFdPropertiesKHR"))
		));
	}
}

#[test]
fn get_memory_fd_properties_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::ExternalMemoryHandleTypeFlagBits,
		arg_2: i32,
		arg_3: *mut vk::MemoryFdPropertiesKHR<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::ExternalMemoryHandleTypeFlagBits::from_raw(305398016_u64 as _)
					&& arg_2 == Default::default()
					&& std::ptr::eq(
						arg_3,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
							as *mut vk::MemoryFdPropertiesKHR<'_>,
					)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetMemoryFdPropertiesKHR = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkGetMemoryFdPropertiesKHR, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkGetMemoryFdPropertiesKHR", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_memory_fd_properties_khr(
					&fixture.device,
					vk::ExternalMemoryHandleTypeFlagBits::from_raw(305398016_u64 as _),
					Default::default(),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::MemoryFdPropertiesKHR<'_>
				),
				expected
			);
			assert_eq!(
				vk::Device::get_memory_fd_properties_khr(
					&fixture.device,
					vk::ExternalMemoryHandleTypeFlagBits::from_raw(305398016_u64 as _),
					Default::default(),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::MemoryFdPropertiesKHR<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[cfg(feature = "platform-fuchsia")]
#[test]
fn get_memory_zircon_handle_fuchsia_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::MemoryGetZirconHandleInfoFUCHSIA<'_>,
		*mut vk::zx_handle_t,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_memory_zircon_handle_fuchsia;
	let _: Signature = vk::Device::get_memory_zircon_handle_fuchsia;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_memory_zircon_handle_fuchsia(
				&fixture.device,
				std::mem::zeroed::<*const vk::MemoryGetZirconHandleInfoFUCHSIA<'_>>(),
				std::mem::zeroed::<*mut vk::zx_handle_t>()
			),
			Err(CallError::MissingCommand("vkGetMemoryZirconHandleFUCHSIA"))
		));
		assert!(matches!(
			fixture.device.get_memory_zircon_handle_fuchsia(
				std::mem::zeroed::<*const vk::MemoryGetZirconHandleInfoFUCHSIA<'_>>(),
				std::mem::zeroed::<*mut vk::zx_handle_t>()
			),
			Err(CallError::MissingCommand("vkGetMemoryZirconHandleFUCHSIA"))
		));
	}
}

#[cfg(feature = "platform-fuchsia")]
#[test]
fn get_memory_zircon_handle_fuchsia_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::MemoryGetZirconHandleInfoFUCHSIA<'_>,
		arg_2: *mut vk::zx_handle_t,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::MemoryGetZirconHandleInfoFUCHSIA<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut vk::zx_handle_t,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetMemoryZirconHandleFUCHSIA = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkGetMemoryZirconHandleFUCHSIA, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkGetMemoryZirconHandleFUCHSIA", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_memory_zircon_handle_fuchsia(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::MemoryGetZirconHandleInfoFUCHSIA<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut vk::zx_handle_t
				),
				expected
			);
			assert_eq!(
				vk::Device::get_memory_zircon_handle_fuchsia(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::MemoryGetZirconHandleInfoFUCHSIA<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut vk::zx_handle_t
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[cfg(feature = "platform-fuchsia")]
#[test]
fn get_memory_zircon_handle_properties_fuchsia_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::ExternalMemoryHandleTypeFlagBits,
		vk::zx_handle_t,
		*mut vk::MemoryZirconHandlePropertiesFUCHSIA<'_>,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_memory_zircon_handle_properties_fuchsia;
	let _: Signature = vk::Device::get_memory_zircon_handle_properties_fuchsia;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_memory_zircon_handle_properties_fuchsia(
				&fixture.device,
				std::mem::zeroed::<vk::ExternalMemoryHandleTypeFlagBits>(),
				std::mem::zeroed::<vk::zx_handle_t>(),
				std::mem::zeroed::<*mut vk::MemoryZirconHandlePropertiesFUCHSIA<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetMemoryZirconHandlePropertiesFUCHSIA"
			))
		));
		assert!(matches!(
			fixture.device.get_memory_zircon_handle_properties_fuchsia(
				std::mem::zeroed::<vk::ExternalMemoryHandleTypeFlagBits>(),
				std::mem::zeroed::<vk::zx_handle_t>(),
				std::mem::zeroed::<*mut vk::MemoryZirconHandlePropertiesFUCHSIA<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetMemoryZirconHandlePropertiesFUCHSIA"
			))
		));
	}
}

#[cfg(feature = "platform-fuchsia")]
#[test]
fn get_memory_zircon_handle_properties_fuchsia_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::ExternalMemoryHandleTypeFlagBits,
		arg_2: vk::zx_handle_t,
		arg_3: *mut vk::MemoryZirconHandlePropertiesFUCHSIA<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::ExternalMemoryHandleTypeFlagBits::from_raw(305398016_u64 as _)
					&& arg_2 == Default::default()
					&& std::ptr::eq(
						arg_3,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
							as *mut vk::MemoryZirconHandlePropertiesFUCHSIA<'_>,
					)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetMemoryZirconHandlePropertiesFUCHSIA = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetMemoryZirconHandlePropertiesFUCHSIA,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkGetMemoryZirconHandlePropertiesFUCHSIA", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_memory_zircon_handle_properties_fuchsia(
					&fixture.device,
					vk::ExternalMemoryHandleTypeFlagBits::from_raw(305398016_u64 as _),
					Default::default(),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::MemoryZirconHandlePropertiesFUCHSIA<'_>
				),
				expected
			);
			assert_eq!(
				vk::Device::get_memory_zircon_handle_properties_fuchsia(
					&fixture.device,
					vk::ExternalMemoryHandleTypeFlagBits::from_raw(305398016_u64 as _),
					Default::default(),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::MemoryZirconHandlePropertiesFUCHSIA<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_memory_remote_address_nv_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::MemoryGetRemoteAddressInfoNV<'_>,
		*mut vk::RemoteAddressNV,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_memory_remote_address_nv;
	let _: Signature = vk::Device::get_memory_remote_address_nv;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_memory_remote_address_nv(
				&fixture.device,
				std::mem::zeroed::<*const vk::MemoryGetRemoteAddressInfoNV<'_>>(),
				std::mem::zeroed::<*mut vk::RemoteAddressNV>()
			),
			Err(CallError::MissingCommand("vkGetMemoryRemoteAddressNV"))
		));
		assert!(matches!(
			fixture.device.get_memory_remote_address_nv(
				std::mem::zeroed::<*const vk::MemoryGetRemoteAddressInfoNV<'_>>(),
				std::mem::zeroed::<*mut vk::RemoteAddressNV>()
			),
			Err(CallError::MissingCommand("vkGetMemoryRemoteAddressNV"))
		));
	}
}

#[test]
fn get_memory_remote_address_nv_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::MemoryGetRemoteAddressInfoNV<'_>,
		arg_2: *mut vk::RemoteAddressNV,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::MemoryGetRemoteAddressInfoNV<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::RemoteAddressNV,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetMemoryRemoteAddressNV = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkGetMemoryRemoteAddressNV, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkGetMemoryRemoteAddressNV", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_memory_remote_address_nv(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::MemoryGetRemoteAddressInfoNV<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::RemoteAddressNV
				),
				expected
			);
			assert_eq!(
				vk::Device::get_memory_remote_address_nv(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::MemoryGetRemoteAddressInfoNV<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::RemoteAddressNV
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_physical_device_external_semaphore_properties_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		vk::PhysicalDevice,
		&vk::PhysicalDeviceExternalSemaphoreInfo<'_>,
		&mut vk::ExternalSemaphoreProperties<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::get_physical_device_external_semaphore_properties;
	let _: Signature = vk::Instance::get_physical_device_external_semaphore_properties;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_physical_device_external_semaphore_properties(
				&fixture.instance,
				Default::default(),
				&std::mem::zeroed::<vk::PhysicalDeviceExternalSemaphoreInfo<'_>>(),
				&mut std::mem::zeroed::<vk::ExternalSemaphoreProperties<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceExternalSemaphoreProperties"
			))
		));
		assert!(matches!(
			fixture
				.instance
				.get_physical_device_external_semaphore_properties(
					Default::default(),
					&std::mem::zeroed::<vk::PhysicalDeviceExternalSemaphoreInfo<'_>>(),
					&mut std::mem::zeroed::<vk::ExternalSemaphoreProperties<'_>>()
				),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceExternalSemaphoreProperties"
			))
		));
	}
}

#[test]
fn get_physical_device_external_semaphore_properties_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		vk::PhysicalDevice,
		&vk::PhysicalDeviceExternalSemaphoreInfo<'_>,
		&mut vk::ExternalSemaphoreProperties<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::get_physical_device_external_semaphore_properties_khr;
	let _: Signature = vk::Instance::get_physical_device_external_semaphore_properties_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_physical_device_external_semaphore_properties_khr(
				&fixture.instance,
				Default::default(),
				&std::mem::zeroed::<vk::PhysicalDeviceExternalSemaphoreInfo<'_>>(),
				&mut std::mem::zeroed::<vk::ExternalSemaphoreProperties<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceExternalSemaphorePropertiesKHR"
			))
		));
		assert!(matches!(
			fixture
				.instance
				.get_physical_device_external_semaphore_properties_khr(
					Default::default(),
					&std::mem::zeroed::<vk::PhysicalDeviceExternalSemaphoreInfo<'_>>(),
					&mut std::mem::zeroed::<vk::ExternalSemaphoreProperties<'_>>()
				),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceExternalSemaphorePropertiesKHR"
			))
		));
	}
}

#[cfg(feature = "platform-win32")]
#[test]
fn get_semaphore_win32_handle_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::SemaphoreGetWin32HandleInfoKHR<'_>,
		*mut vk::HANDLE,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_semaphore_win32_handle_khr;
	let _: Signature = vk::Device::get_semaphore_win32_handle_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_semaphore_win32_handle_khr(
				&fixture.device,
				std::mem::zeroed::<*const vk::SemaphoreGetWin32HandleInfoKHR<'_>>(),
				std::mem::zeroed::<*mut vk::HANDLE>()
			),
			Err(CallError::MissingCommand("vkGetSemaphoreWin32HandleKHR"))
		));
		assert!(matches!(
			fixture.device.get_semaphore_win32_handle_khr(
				std::mem::zeroed::<*const vk::SemaphoreGetWin32HandleInfoKHR<'_>>(),
				std::mem::zeroed::<*mut vk::HANDLE>()
			),
			Err(CallError::MissingCommand("vkGetSemaphoreWin32HandleKHR"))
		));
	}
}

#[cfg(feature = "platform-win32")]
#[test]
fn get_semaphore_win32_handle_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::SemaphoreGetWin32HandleInfoKHR<'_>,
		arg_2: *mut vk::HANDLE,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::SemaphoreGetWin32HandleInfoKHR<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut vk::HANDLE,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetSemaphoreWin32HandleKHR = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkGetSemaphoreWin32HandleKHR, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkGetSemaphoreWin32HandleKHR", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_semaphore_win32_handle_khr(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::SemaphoreGetWin32HandleInfoKHR<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut vk::HANDLE
				),
				expected
			);
			assert_eq!(
				vk::Device::get_semaphore_win32_handle_khr(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::SemaphoreGetWin32HandleInfoKHR<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut vk::HANDLE
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[cfg(feature = "platform-win32")]
#[test]
fn import_semaphore_win32_handle_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::ImportSemaphoreWin32HandleInfoKHR<'_>,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::import_semaphore_win32_handle_khr;
	let _: Signature = vk::Device::import_semaphore_win32_handle_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::import_semaphore_win32_handle_khr(
				&fixture.device,
				std::mem::zeroed::<*const vk::ImportSemaphoreWin32HandleInfoKHR<'_>>()
			),
			Err(CallError::MissingCommand("vkImportSemaphoreWin32HandleKHR"))
		));
		assert!(matches!(
			fixture
				.device
				.import_semaphore_win32_handle_khr(std::mem::zeroed::<
					*const vk::ImportSemaphoreWin32HandleInfoKHR<'_>,
				>()),
			Err(CallError::MissingCommand("vkImportSemaphoreWin32HandleKHR"))
		));
	}
}

#[cfg(feature = "platform-win32")]
#[test]
fn import_semaphore_win32_handle_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::ImportSemaphoreWin32HandleInfoKHR<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::ImportSemaphoreWin32HandleInfoKHR<'_>,
					)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkImportSemaphoreWin32HandleKHR = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkImportSemaphoreWin32HandleKHR, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkImportSemaphoreWin32HandleKHR", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::import_semaphore_win32_handle_khr(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::ImportSemaphoreWin32HandleInfoKHR<'_>
				),
				expected
			);
			assert_eq!(
				vk::Device::import_semaphore_win32_handle_khr(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::ImportSemaphoreWin32HandleInfoKHR<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_semaphore_fd_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::SemaphoreGetFdInfoKHR<'_>,
		*mut i32,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_semaphore_fd_khr;
	let _: Signature = vk::Device::get_semaphore_fd_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_semaphore_fd_khr(
				&fixture.device,
				std::mem::zeroed::<*const vk::SemaphoreGetFdInfoKHR<'_>>(),
				std::mem::zeroed::<*mut i32>()
			),
			Err(CallError::MissingCommand("vkGetSemaphoreFdKHR"))
		));
		assert!(matches!(
			fixture.device.get_semaphore_fd_khr(
				std::mem::zeroed::<*const vk::SemaphoreGetFdInfoKHR<'_>>(),
				std::mem::zeroed::<*mut i32>()
			),
			Err(CallError::MissingCommand("vkGetSemaphoreFdKHR"))
		));
	}
}

#[test]
fn get_semaphore_fd_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::SemaphoreGetFdInfoKHR<'_>,
		arg_2: *mut i32,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::SemaphoreGetFdInfoKHR<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut i32,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetSemaphoreFdKHR = Some(mock);
		let erased = std::mem::transmute::<vk::PFN_vkGetSemaphoreFdKHR, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkGetSemaphoreFdKHR", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_semaphore_fd_khr(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::SemaphoreGetFdInfoKHR<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut i32
				),
				expected
			);
			assert_eq!(
				vk::Device::get_semaphore_fd_khr(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::SemaphoreGetFdInfoKHR<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut i32
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn import_semaphore_fd_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::ImportSemaphoreFdInfoKHR<'_>,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::import_semaphore_fd_khr;
	let _: Signature = vk::Device::import_semaphore_fd_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::import_semaphore_fd_khr(
				&fixture.device,
				std::mem::zeroed::<*const vk::ImportSemaphoreFdInfoKHR<'_>>()
			),
			Err(CallError::MissingCommand("vkImportSemaphoreFdKHR"))
		));
		assert!(matches!(
			fixture
				.device
				.import_semaphore_fd_khr(std::mem::zeroed::<*const vk::ImportSemaphoreFdInfoKHR<'_>>()),
			Err(CallError::MissingCommand("vkImportSemaphoreFdKHR"))
		));
	}
}

#[test]
fn import_semaphore_fd_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::ImportSemaphoreFdInfoKHR<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::ImportSemaphoreFdInfoKHR<'_>,
					)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkImportSemaphoreFdKHR = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkImportSemaphoreFdKHR, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkImportSemaphoreFdKHR", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::import_semaphore_fd_khr(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::ImportSemaphoreFdInfoKHR<'_>
				),
				expected
			);
			assert_eq!(
				vk::Device::import_semaphore_fd_khr(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::ImportSemaphoreFdInfoKHR<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[cfg(feature = "platform-fuchsia")]
#[test]
fn get_semaphore_zircon_handle_fuchsia_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::SemaphoreGetZirconHandleInfoFUCHSIA<'_>,
		*mut vk::zx_handle_t,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_semaphore_zircon_handle_fuchsia;
	let _: Signature = vk::Device::get_semaphore_zircon_handle_fuchsia;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_semaphore_zircon_handle_fuchsia(
				&fixture.device,
				std::mem::zeroed::<*const vk::SemaphoreGetZirconHandleInfoFUCHSIA<'_>>(),
				std::mem::zeroed::<*mut vk::zx_handle_t>()
			),
			Err(CallError::MissingCommand(
				"vkGetSemaphoreZirconHandleFUCHSIA"
			))
		));
		assert!(matches!(
			fixture.device.get_semaphore_zircon_handle_fuchsia(
				std::mem::zeroed::<*const vk::SemaphoreGetZirconHandleInfoFUCHSIA<'_>>(),
				std::mem::zeroed::<*mut vk::zx_handle_t>()
			),
			Err(CallError::MissingCommand(
				"vkGetSemaphoreZirconHandleFUCHSIA"
			))
		));
	}
}

#[cfg(feature = "platform-fuchsia")]
#[test]
fn get_semaphore_zircon_handle_fuchsia_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::SemaphoreGetZirconHandleInfoFUCHSIA<'_>,
		arg_2: *mut vk::zx_handle_t,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::SemaphoreGetZirconHandleInfoFUCHSIA<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut vk::zx_handle_t,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetSemaphoreZirconHandleFUCHSIA = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetSemaphoreZirconHandleFUCHSIA,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkGetSemaphoreZirconHandleFUCHSIA", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_semaphore_zircon_handle_fuchsia(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::SemaphoreGetZirconHandleInfoFUCHSIA<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut vk::zx_handle_t
				),
				expected
			);
			assert_eq!(
				vk::Device::get_semaphore_zircon_handle_fuchsia(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::SemaphoreGetZirconHandleInfoFUCHSIA<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut vk::zx_handle_t
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[cfg(feature = "platform-fuchsia")]
#[test]
fn import_semaphore_zircon_handle_fuchsia_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::ImportSemaphoreZirconHandleInfoFUCHSIA<'_>,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::import_semaphore_zircon_handle_fuchsia;
	let _: Signature = vk::Device::import_semaphore_zircon_handle_fuchsia;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::import_semaphore_zircon_handle_fuchsia(
				&fixture.device,
				std::mem::zeroed::<*const vk::ImportSemaphoreZirconHandleInfoFUCHSIA<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkImportSemaphoreZirconHandleFUCHSIA"
			))
		));
		assert!(matches!(
			fixture
				.device
				.import_semaphore_zircon_handle_fuchsia(std::mem::zeroed::<
					*const vk::ImportSemaphoreZirconHandleInfoFUCHSIA<'_>,
				>()),
			Err(CallError::MissingCommand(
				"vkImportSemaphoreZirconHandleFUCHSIA"
			))
		));
	}
}

#[cfg(feature = "platform-fuchsia")]
#[test]
fn import_semaphore_zircon_handle_fuchsia_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::ImportSemaphoreZirconHandleInfoFUCHSIA<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::ImportSemaphoreZirconHandleInfoFUCHSIA<'_>,
					)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkImportSemaphoreZirconHandleFUCHSIA = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkImportSemaphoreZirconHandleFUCHSIA,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkImportSemaphoreZirconHandleFUCHSIA", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::import_semaphore_zircon_handle_fuchsia(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::ImportSemaphoreZirconHandleInfoFUCHSIA<'_>
				),
				expected
			);
			assert_eq!(
				vk::Device::import_semaphore_zircon_handle_fuchsia(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::ImportSemaphoreZirconHandleInfoFUCHSIA<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_physical_device_external_fence_properties_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		vk::PhysicalDevice,
		&vk::PhysicalDeviceExternalFenceInfo<'_>,
		&mut vk::ExternalFenceProperties<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::get_physical_device_external_fence_properties;
	let _: Signature = vk::Instance::get_physical_device_external_fence_properties;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_physical_device_external_fence_properties(
				&fixture.instance,
				Default::default(),
				&std::mem::zeroed::<vk::PhysicalDeviceExternalFenceInfo<'_>>(),
				&mut std::mem::zeroed::<vk::ExternalFenceProperties<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceExternalFenceProperties"
			))
		));
		assert!(matches!(
			fixture
				.instance
				.get_physical_device_external_fence_properties(
					Default::default(),
					&std::mem::zeroed::<vk::PhysicalDeviceExternalFenceInfo<'_>>(),
					&mut std::mem::zeroed::<vk::ExternalFenceProperties<'_>>()
				),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceExternalFenceProperties"
			))
		));
	}
}

#[test]
fn get_physical_device_external_fence_properties_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		vk::PhysicalDevice,
		&vk::PhysicalDeviceExternalFenceInfo<'_>,
		&mut vk::ExternalFenceProperties<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::get_physical_device_external_fence_properties_khr;
	let _: Signature = vk::Instance::get_physical_device_external_fence_properties_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_physical_device_external_fence_properties_khr(
				&fixture.instance,
				Default::default(),
				&std::mem::zeroed::<vk::PhysicalDeviceExternalFenceInfo<'_>>(),
				&mut std::mem::zeroed::<vk::ExternalFenceProperties<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceExternalFencePropertiesKHR"
			))
		));
		assert!(matches!(
			fixture
				.instance
				.get_physical_device_external_fence_properties_khr(
					Default::default(),
					&std::mem::zeroed::<vk::PhysicalDeviceExternalFenceInfo<'_>>(),
					&mut std::mem::zeroed::<vk::ExternalFenceProperties<'_>>()
				),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceExternalFencePropertiesKHR"
			))
		));
	}
}

#[cfg(feature = "platform-win32")]
#[test]
fn get_fence_win32_handle_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::FenceGetWin32HandleInfoKHR<'_>,
		*mut vk::HANDLE,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_fence_win32_handle_khr;
	let _: Signature = vk::Device::get_fence_win32_handle_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_fence_win32_handle_khr(
				&fixture.device,
				std::mem::zeroed::<*const vk::FenceGetWin32HandleInfoKHR<'_>>(),
				std::mem::zeroed::<*mut vk::HANDLE>()
			),
			Err(CallError::MissingCommand("vkGetFenceWin32HandleKHR"))
		));
		assert!(matches!(
			fixture.device.get_fence_win32_handle_khr(
				std::mem::zeroed::<*const vk::FenceGetWin32HandleInfoKHR<'_>>(),
				std::mem::zeroed::<*mut vk::HANDLE>()
			),
			Err(CallError::MissingCommand("vkGetFenceWin32HandleKHR"))
		));
	}
}

#[cfg(feature = "platform-win32")]
#[test]
fn get_fence_win32_handle_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::FenceGetWin32HandleInfoKHR<'_>,
		arg_2: *mut vk::HANDLE,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::FenceGetWin32HandleInfoKHR<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut vk::HANDLE,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetFenceWin32HandleKHR = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkGetFenceWin32HandleKHR, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkGetFenceWin32HandleKHR", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_fence_win32_handle_khr(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::FenceGetWin32HandleInfoKHR<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut vk::HANDLE
				),
				expected
			);
			assert_eq!(
				vk::Device::get_fence_win32_handle_khr(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::FenceGetWin32HandleInfoKHR<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut vk::HANDLE
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[cfg(feature = "platform-win32")]
#[test]
fn import_fence_win32_handle_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::ImportFenceWin32HandleInfoKHR<'_>,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::import_fence_win32_handle_khr;
	let _: Signature = vk::Device::import_fence_win32_handle_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::import_fence_win32_handle_khr(
				&fixture.device,
				std::mem::zeroed::<*const vk::ImportFenceWin32HandleInfoKHR<'_>>()
			),
			Err(CallError::MissingCommand("vkImportFenceWin32HandleKHR"))
		));
		assert!(matches!(
			fixture
				.device
				.import_fence_win32_handle_khr(std::mem::zeroed::<
					*const vk::ImportFenceWin32HandleInfoKHR<'_>,
				>()),
			Err(CallError::MissingCommand("vkImportFenceWin32HandleKHR"))
		));
	}
}

#[cfg(feature = "platform-win32")]
#[test]
fn import_fence_win32_handle_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::ImportFenceWin32HandleInfoKHR<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::ImportFenceWin32HandleInfoKHR<'_>,
					)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkImportFenceWin32HandleKHR = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkImportFenceWin32HandleKHR, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkImportFenceWin32HandleKHR", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::import_fence_win32_handle_khr(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::ImportFenceWin32HandleInfoKHR<'_>
				),
				expected
			);
			assert_eq!(
				vk::Device::import_fence_win32_handle_khr(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::ImportFenceWin32HandleInfoKHR<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_fence_fd_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::FenceGetFdInfoKHR<'_>,
		*mut i32,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_fence_fd_khr;
	let _: Signature = vk::Device::get_fence_fd_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_fence_fd_khr(
				&fixture.device,
				std::mem::zeroed::<*const vk::FenceGetFdInfoKHR<'_>>(),
				std::mem::zeroed::<*mut i32>()
			),
			Err(CallError::MissingCommand("vkGetFenceFdKHR"))
		));
		assert!(matches!(
			fixture.device.get_fence_fd_khr(
				std::mem::zeroed::<*const vk::FenceGetFdInfoKHR<'_>>(),
				std::mem::zeroed::<*mut i32>()
			),
			Err(CallError::MissingCommand("vkGetFenceFdKHR"))
		));
	}
}

#[test]
fn get_fence_fd_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::FenceGetFdInfoKHR<'_>,
		arg_2: *mut i32,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::FenceGetFdInfoKHR<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut i32,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetFenceFdKHR = Some(mock);
		let erased = std::mem::transmute::<vk::PFN_vkGetFenceFdKHR, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkGetFenceFdKHR", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_fence_fd_khr(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::FenceGetFdInfoKHR<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut i32
				),
				expected
			);
			assert_eq!(
				vk::Device::get_fence_fd_khr(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::FenceGetFdInfoKHR<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut i32
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn import_fence_fd_khr_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, *const vk::ImportFenceFdInfoKHR<'_>) -> Result<vk::Result, CallError>;
	let _: Signature = vk::import_fence_fd_khr;
	let _: Signature = vk::Device::import_fence_fd_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::import_fence_fd_khr(
				&fixture.device,
				std::mem::zeroed::<*const vk::ImportFenceFdInfoKHR<'_>>()
			),
			Err(CallError::MissingCommand("vkImportFenceFdKHR"))
		));
		assert!(matches!(
			fixture
				.device
				.import_fence_fd_khr(std::mem::zeroed::<*const vk::ImportFenceFdInfoKHR<'_>>()),
			Err(CallError::MissingCommand("vkImportFenceFdKHR"))
		));
	}
}

#[test]
fn import_fence_fd_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::ImportFenceFdInfoKHR<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::ImportFenceFdInfoKHR<'_>,
					)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkImportFenceFdKHR = Some(mock);
		let erased = std::mem::transmute::<vk::PFN_vkImportFenceFdKHR, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkImportFenceFdKHR", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::import_fence_fd_khr(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::ImportFenceFdInfoKHR<'_>
				),
				expected
			);
			assert_eq!(
				vk::Device::import_fence_fd_khr(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::ImportFenceFdInfoKHR<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn release_display_ext_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Instance, vk::PhysicalDevice, vk::DisplayKHR) -> Result<vk::Result, CallError>;
	let _: Signature = vk::release_display_ext;
	let _: Signature = vk::Instance::release_display_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::release_display_ext(
				&fixture.instance,
				std::mem::zeroed::<vk::PhysicalDevice>(),
				std::mem::zeroed::<vk::DisplayKHR>()
			),
			Err(CallError::MissingCommand("vkReleaseDisplayEXT"))
		));
		assert!(matches!(
			fixture.instance.release_display_ext(
				std::mem::zeroed::<vk::PhysicalDevice>(),
				std::mem::zeroed::<vk::DisplayKHR>()
			),
			Err(CallError::MissingCommand("vkReleaseDisplayEXT"))
		));
	}
}

#[test]
fn release_display_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::PhysicalDevice, arg_1: vk::DisplayKHR) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::PhysicalDevice::from_raw(305397760_u64 as _)
					&& arg_1 == vk::DisplayKHR::from_raw(305398016_u64 as _)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkReleaseDisplayEXT = Some(mock);
		let erased = std::mem::transmute::<vk::PFN_vkReleaseDisplayEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkReleaseDisplayEXT", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::release_display_ext(
					&fixture.instance,
					vk::PhysicalDevice::from_raw(305397760_u64 as _),
					vk::DisplayKHR::from_raw(305398016_u64 as _)
				),
				expected
			);
			assert_eq!(
				vk::Instance::release_display_ext(
					&fixture.instance,
					vk::PhysicalDevice::from_raw(305397760_u64 as _),
					vk::DisplayKHR::from_raw(305398016_u64 as _)
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[cfg(feature = "platform-xlib-xrandr")]
#[test]
fn acquire_xlib_display_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		vk::PhysicalDevice,
		*mut vk::Display,
		vk::DisplayKHR,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::acquire_xlib_display_ext;
	let _: Signature = vk::Instance::acquire_xlib_display_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::acquire_xlib_display_ext(
				&fixture.instance,
				std::mem::zeroed::<vk::PhysicalDevice>(),
				std::mem::zeroed::<*mut vk::Display>(),
				std::mem::zeroed::<vk::DisplayKHR>()
			),
			Err(CallError::MissingCommand("vkAcquireXlibDisplayEXT"))
		));
		assert!(matches!(
			fixture.instance.acquire_xlib_display_ext(
				std::mem::zeroed::<vk::PhysicalDevice>(),
				std::mem::zeroed::<*mut vk::Display>(),
				std::mem::zeroed::<vk::DisplayKHR>()
			),
			Err(CallError::MissingCommand("vkAcquireXlibDisplayEXT"))
		));
	}
}

#[cfg(feature = "platform-xlib-xrandr")]
#[test]
fn acquire_xlib_display_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::PhysicalDevice,
		arg_1: *mut vk::Display,
		arg_2: vk::DisplayKHR,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::PhysicalDevice::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016) as *mut vk::Display,
					) && arg_2 == vk::DisplayKHR::from_raw(305398272_u64 as _)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkAcquireXlibDisplayEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkAcquireXlibDisplayEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkAcquireXlibDisplayEXT", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::acquire_xlib_display_ext(
					&fixture.instance,
					vk::PhysicalDevice::from_raw(305397760_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016) as *mut vk::Display,
					vk::DisplayKHR::from_raw(305398272_u64 as _)
				),
				expected
			);
			assert_eq!(
				vk::Instance::acquire_xlib_display_ext(
					&fixture.instance,
					vk::PhysicalDevice::from_raw(305397760_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016) as *mut vk::Display,
					vk::DisplayKHR::from_raw(305398272_u64 as _)
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[cfg(feature = "platform-xlib-xrandr")]
#[test]
fn get_rand_r_output_display_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		vk::PhysicalDevice,
		*mut vk::Display,
		vk::RROutput,
		*mut vk::DisplayKHR,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_rand_r_output_display_ext;
	let _: Signature = vk::Instance::get_rand_r_output_display_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_rand_r_output_display_ext(
				&fixture.instance,
				std::mem::zeroed::<vk::PhysicalDevice>(),
				std::mem::zeroed::<*mut vk::Display>(),
				std::mem::zeroed::<vk::RROutput>(),
				std::mem::zeroed::<*mut vk::DisplayKHR>()
			),
			Err(CallError::MissingCommand("vkGetRandROutputDisplayEXT"))
		));
		assert!(matches!(
			fixture.instance.get_rand_r_output_display_ext(
				std::mem::zeroed::<vk::PhysicalDevice>(),
				std::mem::zeroed::<*mut vk::Display>(),
				std::mem::zeroed::<vk::RROutput>(),
				std::mem::zeroed::<*mut vk::DisplayKHR>()
			),
			Err(CallError::MissingCommand("vkGetRandROutputDisplayEXT"))
		));
	}
}

#[cfg(feature = "platform-xlib-xrandr")]
#[test]
fn get_rand_r_output_display_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::PhysicalDevice,
		arg_1: *mut vk::Display,
		arg_2: vk::RROutput,
		arg_3: *mut vk::DisplayKHR,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::PhysicalDevice::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016) as *mut vk::Display,
					) && arg_2 == Default::default()
					&& std::ptr::eq(
						arg_3,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::DisplayKHR,
					)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetRandROutputDisplayEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkGetRandROutputDisplayEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkGetRandROutputDisplayEXT", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_rand_r_output_display_ext(
					&fixture.instance,
					vk::PhysicalDevice::from_raw(305397760_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016) as *mut vk::Display,
					Default::default(),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::DisplayKHR
				),
				expected
			);
			assert_eq!(
				vk::Instance::get_rand_r_output_display_ext(
					&fixture.instance,
					vk::PhysicalDevice::from_raw(305397760_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016) as *mut vk::Display,
					Default::default(),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::DisplayKHR
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[cfg(feature = "platform-win32")]
#[test]
fn acquire_winrt_display_nv_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Instance, vk::PhysicalDevice, vk::DisplayKHR) -> Result<vk::Result, CallError>;
	let _: Signature = vk::acquire_winrt_display_nv;
	let _: Signature = vk::Instance::acquire_winrt_display_nv;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::acquire_winrt_display_nv(
				&fixture.instance,
				std::mem::zeroed::<vk::PhysicalDevice>(),
				std::mem::zeroed::<vk::DisplayKHR>()
			),
			Err(CallError::MissingCommand("vkAcquireWinrtDisplayNV"))
		));
		assert!(matches!(
			fixture.instance.acquire_winrt_display_nv(
				std::mem::zeroed::<vk::PhysicalDevice>(),
				std::mem::zeroed::<vk::DisplayKHR>()
			),
			Err(CallError::MissingCommand("vkAcquireWinrtDisplayNV"))
		));
	}
}

#[cfg(feature = "platform-win32")]
#[test]
fn acquire_winrt_display_nv_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::PhysicalDevice, arg_1: vk::DisplayKHR) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::PhysicalDevice::from_raw(305397760_u64 as _)
					&& arg_1 == vk::DisplayKHR::from_raw(305398016_u64 as _)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkAcquireWinrtDisplayNV = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkAcquireWinrtDisplayNV, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkAcquireWinrtDisplayNV", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::acquire_winrt_display_nv(
					&fixture.instance,
					vk::PhysicalDevice::from_raw(305397760_u64 as _),
					vk::DisplayKHR::from_raw(305398016_u64 as _)
				),
				expected
			);
			assert_eq!(
				vk::Instance::acquire_winrt_display_nv(
					&fixture.instance,
					vk::PhysicalDevice::from_raw(305397760_u64 as _),
					vk::DisplayKHR::from_raw(305398016_u64 as _)
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[cfg(feature = "platform-win32")]
#[test]
fn get_winrt_display_nv_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		vk::PhysicalDevice,
		u32,
		*mut vk::DisplayKHR,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_winrt_display_nv;
	let _: Signature = vk::Instance::get_winrt_display_nv;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_winrt_display_nv(
				&fixture.instance,
				std::mem::zeroed::<vk::PhysicalDevice>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*mut vk::DisplayKHR>()
			),
			Err(CallError::MissingCommand("vkGetWinrtDisplayNV"))
		));
		assert!(matches!(
			fixture.instance.get_winrt_display_nv(
				std::mem::zeroed::<vk::PhysicalDevice>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*mut vk::DisplayKHR>()
			),
			Err(CallError::MissingCommand("vkGetWinrtDisplayNV"))
		));
	}
}

#[cfg(feature = "platform-win32")]
#[test]
fn get_winrt_display_nv_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::PhysicalDevice,
		arg_1: u32,
		arg_2: *mut vk::DisplayKHR,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::PhysicalDevice::from_raw(305397760_u64 as _)
					&& arg_1 == Default::default()
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut vk::DisplayKHR,
					)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetWinrtDisplayNV = Some(mock);
		let erased = std::mem::transmute::<vk::PFN_vkGetWinrtDisplayNV, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkGetWinrtDisplayNV", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_winrt_display_nv(
					&fixture.instance,
					vk::PhysicalDevice::from_raw(305397760_u64 as _),
					Default::default(),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut vk::DisplayKHR
				),
				expected
			);
			assert_eq!(
				vk::Instance::get_winrt_display_nv(
					&fixture.instance,
					vk::PhysicalDevice::from_raw(305397760_u64 as _),
					Default::default(),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut vk::DisplayKHR
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn display_power_control_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::DisplayKHR,
		*const vk::DisplayPowerInfoEXT<'_>,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::display_power_control_ext;
	let _: Signature = vk::Device::display_power_control_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::display_power_control_ext(
				&fixture.device,
				std::mem::zeroed::<vk::DisplayKHR>(),
				std::mem::zeroed::<*const vk::DisplayPowerInfoEXT<'_>>()
			),
			Err(CallError::MissingCommand("vkDisplayPowerControlEXT"))
		));
		assert!(matches!(
			fixture.device.display_power_control_ext(
				std::mem::zeroed::<vk::DisplayKHR>(),
				std::mem::zeroed::<*const vk::DisplayPowerInfoEXT<'_>>()
			),
			Err(CallError::MissingCommand("vkDisplayPowerControlEXT"))
		));
	}
}

#[test]
fn display_power_control_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::DisplayKHR,
		arg_2: *const vk::DisplayPowerInfoEXT<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::DisplayKHR::from_raw(305398016_u64 as _)
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *const vk::DisplayPowerInfoEXT<'_>,
					)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkDisplayPowerControlEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkDisplayPowerControlEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkDisplayPowerControlEXT", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::display_power_control_ext(
					&fixture.device,
					vk::DisplayKHR::from_raw(305398016_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::DisplayPowerInfoEXT<'_>
				),
				expected
			);
			assert_eq!(
				vk::Device::display_power_control_ext(
					&fixture.device,
					vk::DisplayKHR::from_raw(305398016_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::DisplayPowerInfoEXT<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn register_device_event_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::DeviceEventInfoEXT<'_>,
		*const vk::AllocationCallbacks,
		*mut vk::Fence,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::register_device_event_ext;
	let _: Signature = vk::Device::register_device_event_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::register_device_event_ext(
				&fixture.device,
				std::mem::zeroed::<*const vk::DeviceEventInfoEXT<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::Fence>()
			),
			Err(CallError::MissingCommand("vkRegisterDeviceEventEXT"))
		));
		assert!(matches!(
			fixture.device.register_device_event_ext(
				std::mem::zeroed::<*const vk::DeviceEventInfoEXT<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::Fence>()
			),
			Err(CallError::MissingCommand("vkRegisterDeviceEventEXT"))
		));
	}
}

#[test]
fn register_device_event_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::DeviceEventInfoEXT<'_>,
		arg_2: *const vk::AllocationCallbacks,
		arg_3: *mut vk::Fence,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::DeviceEventInfoEXT<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
				) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::Fence,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkRegisterDeviceEventEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkRegisterDeviceEventEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkRegisterDeviceEventEXT", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::register_device_event_ext(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::DeviceEventInfoEXT<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::Fence
				),
				expected
			);
			assert_eq!(
				vk::Device::register_device_event_ext(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::DeviceEventInfoEXT<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::Fence
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn register_display_event_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::DisplayKHR,
		*const vk::DisplayEventInfoEXT<'_>,
		*const vk::AllocationCallbacks,
		*mut vk::Fence,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::register_display_event_ext;
	let _: Signature = vk::Device::register_display_event_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::register_display_event_ext(
				&fixture.device,
				std::mem::zeroed::<vk::DisplayKHR>(),
				std::mem::zeroed::<*const vk::DisplayEventInfoEXT<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::Fence>()
			),
			Err(CallError::MissingCommand("vkRegisterDisplayEventEXT"))
		));
		assert!(matches!(
			fixture.device.register_display_event_ext(
				std::mem::zeroed::<vk::DisplayKHR>(),
				std::mem::zeroed::<*const vk::DisplayEventInfoEXT<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::Fence>()
			),
			Err(CallError::MissingCommand("vkRegisterDisplayEventEXT"))
		));
	}
}

#[test]
fn register_display_event_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::DisplayKHR,
		arg_2: *const vk::DisplayEventInfoEXT<'_>,
		arg_3: *const vk::AllocationCallbacks,
		arg_4: *mut vk::Fence,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::DisplayKHR::from_raw(305398016_u64 as _)
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *const vk::DisplayEventInfoEXT<'_>,
					) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *const vk::AllocationCallbacks,
				) && std::ptr::eq(
					arg_4,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784) as *mut vk::Fence,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkRegisterDisplayEventEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkRegisterDisplayEventEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkRegisterDisplayEventEXT", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::register_display_event_ext(
					&fixture.device,
					vk::DisplayKHR::from_raw(305398016_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::DisplayEventInfoEXT<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784) as *mut vk::Fence
				),
				expected
			);
			assert_eq!(
				vk::Device::register_display_event_ext(
					&fixture.device,
					vk::DisplayKHR::from_raw(305398016_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::DisplayEventInfoEXT<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784) as *mut vk::Fence
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_swapchain_counter_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::SwapchainKHR,
		vk::SurfaceCounterFlagBitsEXT,
		*mut u64,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_swapchain_counter_ext;
	let _: Signature = vk::Device::get_swapchain_counter_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_swapchain_counter_ext(
				&fixture.device,
				std::mem::zeroed::<vk::SwapchainKHR>(),
				std::mem::zeroed::<vk::SurfaceCounterFlagBitsEXT>(),
				std::mem::zeroed::<*mut u64>()
			),
			Err(CallError::MissingCommand("vkGetSwapchainCounterEXT"))
		));
		assert!(matches!(
			fixture.device.get_swapchain_counter_ext(
				std::mem::zeroed::<vk::SwapchainKHR>(),
				std::mem::zeroed::<vk::SurfaceCounterFlagBitsEXT>(),
				std::mem::zeroed::<*mut u64>()
			),
			Err(CallError::MissingCommand("vkGetSwapchainCounterEXT"))
		));
	}
}

#[test]
fn get_swapchain_counter_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::SwapchainKHR,
		arg_2: vk::SurfaceCounterFlagBitsEXT,
		arg_3: *mut u64,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::SwapchainKHR::from_raw(305398016_u64 as _)
					&& arg_2 == vk::SurfaceCounterFlagBitsEXT::from_raw(305398272_u64 as _)
					&& std::ptr::eq(
						arg_3,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut u64,
					)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetSwapchainCounterEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkGetSwapchainCounterEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkGetSwapchainCounterEXT", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_swapchain_counter_ext(
					&fixture.device,
					vk::SwapchainKHR::from_raw(305398016_u64 as _),
					vk::SurfaceCounterFlagBitsEXT::from_raw(305398272_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut u64
				),
				expected
			);
			assert_eq!(
				vk::Device::get_swapchain_counter_ext(
					&fixture.device,
					vk::SwapchainKHR::from_raw(305398016_u64 as _),
					vk::SurfaceCounterFlagBitsEXT::from_raw(305398272_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut u64
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_physical_device_surface_capabilities2_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		vk::PhysicalDevice,
		vk::SurfaceKHR,
		*mut vk::SurfaceCapabilities2EXT<'_>,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_physical_device_surface_capabilities2_ext;
	let _: Signature = vk::Instance::get_physical_device_surface_capabilities2_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_physical_device_surface_capabilities2_ext(
				&fixture.instance,
				std::mem::zeroed::<vk::PhysicalDevice>(),
				std::mem::zeroed::<vk::SurfaceKHR>(),
				std::mem::zeroed::<*mut vk::SurfaceCapabilities2EXT<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceSurfaceCapabilities2EXT"
			))
		));
		assert!(matches!(
			fixture
				.instance
				.get_physical_device_surface_capabilities2_ext(
					std::mem::zeroed::<vk::PhysicalDevice>(),
					std::mem::zeroed::<vk::SurfaceKHR>(),
					std::mem::zeroed::<*mut vk::SurfaceCapabilities2EXT<'_>>()
				),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceSurfaceCapabilities2EXT"
			))
		));
	}
}

#[test]
fn get_physical_device_surface_capabilities2_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::PhysicalDevice,
		arg_1: vk::SurfaceKHR,
		arg_2: *mut vk::SurfaceCapabilities2EXT<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::PhysicalDevice::from_raw(305397760_u64 as _)
					&& arg_1 == vk::SurfaceKHR::from_raw(305398016_u64 as _)
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *mut vk::SurfaceCapabilities2EXT<'_>,
					)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkGetPhysicalDeviceSurfaceCapabilities2EXT", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_physical_device_surface_capabilities2_ext(
					&fixture.instance,
					vk::PhysicalDevice::from_raw(305397760_u64 as _),
					vk::SurfaceKHR::from_raw(305398016_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::SurfaceCapabilities2EXT<'_>
				),
				expected
			);
			assert_eq!(
				vk::Instance::get_physical_device_surface_capabilities2_ext(
					&fixture.instance,
					vk::PhysicalDevice::from_raw(305397760_u64 as _),
					vk::SurfaceKHR::from_raw(305398016_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::SurfaceCapabilities2EXT<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn enumerate_physical_device_groups_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		&mut u32,
		Option<&mut [vk::PhysicalDeviceGroupProperties<'_>]>,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::enumerate_physical_device_groups;
	let _: Signature = vk::Instance::enumerate_physical_device_groups;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::enumerate_physical_device_groups(&fixture.instance, &mut 0, None),
			Err(CallError::MissingCommand("vkEnumeratePhysicalDeviceGroups"))
		));
		assert!(matches!(
			fixture
				.instance
				.enumerate_physical_device_groups(&mut 0, None),
			Err(CallError::MissingCommand("vkEnumeratePhysicalDeviceGroups"))
		));
	}
}

#[test]
fn enumerate_physical_device_groups_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		&mut u32,
		Option<&mut [vk::PhysicalDeviceGroupProperties<'_>]>,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::enumerate_physical_device_groups_khr;
	let _: Signature = vk::Instance::enumerate_physical_device_groups_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::enumerate_physical_device_groups_khr(&fixture.instance, &mut 0, None),
			Err(CallError::MissingCommand(
				"vkEnumeratePhysicalDeviceGroupsKHR"
			))
		));
		assert!(matches!(
			fixture
				.instance
				.enumerate_physical_device_groups_khr(&mut 0, None),
			Err(CallError::MissingCommand(
				"vkEnumeratePhysicalDeviceGroupsKHR"
			))
		));
	}
}

#[test]
fn get_device_group_peer_memory_features_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, u32, u32, u32, &mut vk::PeerMemoryFeatureFlags) -> Result<(), CallError>;
	let _: Signature = vk::get_device_group_peer_memory_features;
	let _: Signature = vk::Device::get_device_group_peer_memory_features;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_device_group_peer_memory_features(
				&fixture.device,
				Default::default(),
				Default::default(),
				Default::default(),
				&mut std::mem::zeroed::<vk::PeerMemoryFeatureFlags>()
			),
			Err(CallError::MissingCommand(
				"vkGetDeviceGroupPeerMemoryFeatures"
			))
		));
		assert!(matches!(
			fixture.device.get_device_group_peer_memory_features(
				Default::default(),
				Default::default(),
				Default::default(),
				&mut std::mem::zeroed::<vk::PeerMemoryFeatureFlags>()
			),
			Err(CallError::MissingCommand(
				"vkGetDeviceGroupPeerMemoryFeatures"
			))
		));
	}
}

#[test]
fn get_device_group_peer_memory_features_khr_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, u32, u32, u32, &mut vk::PeerMemoryFeatureFlags) -> Result<(), CallError>;
	let _: Signature = vk::get_device_group_peer_memory_features_khr;
	let _: Signature = vk::Device::get_device_group_peer_memory_features_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_device_group_peer_memory_features_khr(
				&fixture.device,
				Default::default(),
				Default::default(),
				Default::default(),
				&mut std::mem::zeroed::<vk::PeerMemoryFeatureFlags>()
			),
			Err(CallError::MissingCommand(
				"vkGetDeviceGroupPeerMemoryFeaturesKHR"
			))
		));
		assert!(matches!(
			fixture.device.get_device_group_peer_memory_features_khr(
				Default::default(),
				Default::default(),
				Default::default(),
				&mut std::mem::zeroed::<vk::PeerMemoryFeatureFlags>()
			),
			Err(CallError::MissingCommand(
				"vkGetDeviceGroupPeerMemoryFeaturesKHR"
			))
		));
	}
}

#[test]
fn bind_buffer_memory2_signature_and_missing_command() {
	type Signature = unsafe fn(&vk::Device, &[vk::BindBufferMemoryInfo<'_>]) -> Result<(), CallError>;
	let _: Signature = vk::bind_buffer_memory2;
	let _: Signature = vk::Device::bind_buffer_memory2;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::bind_buffer_memory2(&fixture.device, &[]),
			Err(CallError::MissingCommand("vkBindBufferMemory2"))
		));
		assert!(matches!(
			fixture.device.bind_buffer_memory2(&[]),
			Err(CallError::MissingCommand("vkBindBufferMemory2"))
		));
	}
}

#[test]
fn bind_buffer_memory2_khr_signature_and_missing_command() {
	type Signature = unsafe fn(&vk::Device, &[vk::BindBufferMemoryInfo<'_>]) -> Result<(), CallError>;
	let _: Signature = vk::bind_buffer_memory2_khr;
	let _: Signature = vk::Device::bind_buffer_memory2_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::bind_buffer_memory2_khr(&fixture.device, &[]),
			Err(CallError::MissingCommand("vkBindBufferMemory2KHR"))
		));
		assert!(matches!(
			fixture.device.bind_buffer_memory2_khr(&[]),
			Err(CallError::MissingCommand("vkBindBufferMemory2KHR"))
		));
	}
}

#[test]
fn bind_image_memory2_signature_and_missing_command() {
	type Signature = unsafe fn(&vk::Device, &[vk::BindImageMemoryInfo<'_>]) -> Result<(), CallError>;
	let _: Signature = vk::bind_image_memory2;
	let _: Signature = vk::Device::bind_image_memory2;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::bind_image_memory2(&fixture.device, &[]),
			Err(CallError::MissingCommand("vkBindImageMemory2"))
		));
		assert!(matches!(
			fixture.device.bind_image_memory2(&[]),
			Err(CallError::MissingCommand("vkBindImageMemory2"))
		));
	}
}

#[test]
fn bind_image_memory2_khr_signature_and_missing_command() {
	type Signature = unsafe fn(&vk::Device, &[vk::BindImageMemoryInfo<'_>]) -> Result<(), CallError>;
	let _: Signature = vk::bind_image_memory2_khr;
	let _: Signature = vk::Device::bind_image_memory2_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::bind_image_memory2_khr(&fixture.device, &[]),
			Err(CallError::MissingCommand("vkBindImageMemory2KHR"))
		));
		assert!(matches!(
			fixture.device.bind_image_memory2_khr(&[]),
			Err(CallError::MissingCommand("vkBindImageMemory2KHR"))
		));
	}
}

#[test]
fn cmd_set_device_mask_signature_and_missing_command() {
	type Signature = unsafe fn(&vk::Device, vk::CommandBuffer, u32) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_device_mask;
	let _: Signature = vk::Device::cmd_set_device_mask;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_device_mask(&fixture.device, Default::default(), Default::default()),
			Err(CallError::MissingCommand("vkCmdSetDeviceMask"))
		));
		assert!(matches!(
			fixture
				.device
				.cmd_set_device_mask(Default::default(), Default::default()),
			Err(CallError::MissingCommand("vkCmdSetDeviceMask"))
		));
	}
}

#[test]
fn cmd_set_device_mask_khr_signature_and_missing_command() {
	type Signature = unsafe fn(&vk::Device, vk::CommandBuffer, u32) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_device_mask_khr;
	let _: Signature = vk::Device::cmd_set_device_mask_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_device_mask_khr(&fixture.device, Default::default(), Default::default()),
			Err(CallError::MissingCommand("vkCmdSetDeviceMaskKHR"))
		));
		assert!(matches!(
			fixture
				.device
				.cmd_set_device_mask_khr(Default::default(), Default::default()),
			Err(CallError::MissingCommand("vkCmdSetDeviceMaskKHR"))
		));
	}
}

#[test]
fn get_device_group_present_capabilities_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*mut vk::DeviceGroupPresentCapabilitiesKHR<'_>,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_device_group_present_capabilities_khr;
	let _: Signature = vk::Device::get_device_group_present_capabilities_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_device_group_present_capabilities_khr(
				&fixture.device,
				std::mem::zeroed::<*mut vk::DeviceGroupPresentCapabilitiesKHR<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetDeviceGroupPresentCapabilitiesKHR"
			))
		));
		assert!(matches!(
			fixture
				.device
				.get_device_group_present_capabilities_khr(std::mem::zeroed::<
					*mut vk::DeviceGroupPresentCapabilitiesKHR<'_>,
				>()),
			Err(CallError::MissingCommand(
				"vkGetDeviceGroupPresentCapabilitiesKHR"
			))
		));
	}
}

#[test]
fn get_device_group_present_capabilities_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *mut vk::DeviceGroupPresentCapabilitiesKHR<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *mut vk::DeviceGroupPresentCapabilitiesKHR<'_>,
					)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetDeviceGroupPresentCapabilitiesKHR = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetDeviceGroupPresentCapabilitiesKHR,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkGetDeviceGroupPresentCapabilitiesKHR", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_device_group_present_capabilities_khr(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *mut vk::DeviceGroupPresentCapabilitiesKHR<'_>
				),
				expected
			);
			assert_eq!(
				vk::Device::get_device_group_present_capabilities_khr(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *mut vk::DeviceGroupPresentCapabilitiesKHR<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_device_group_surface_present_modes_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::SurfaceKHR,
		*mut vk::DeviceGroupPresentModeFlagsKHR,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_device_group_surface_present_modes_khr;
	let _: Signature = vk::Device::get_device_group_surface_present_modes_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_device_group_surface_present_modes_khr(
				&fixture.device,
				std::mem::zeroed::<vk::SurfaceKHR>(),
				std::mem::zeroed::<*mut vk::DeviceGroupPresentModeFlagsKHR>()
			),
			Err(CallError::MissingCommand(
				"vkGetDeviceGroupSurfacePresentModesKHR"
			))
		));
		assert!(matches!(
			fixture.device.get_device_group_surface_present_modes_khr(
				std::mem::zeroed::<vk::SurfaceKHR>(),
				std::mem::zeroed::<*mut vk::DeviceGroupPresentModeFlagsKHR>()
			),
			Err(CallError::MissingCommand(
				"vkGetDeviceGroupSurfacePresentModesKHR"
			))
		));
	}
}

#[test]
fn get_device_group_surface_present_modes_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::SurfaceKHR,
		arg_2: *mut vk::DeviceGroupPresentModeFlagsKHR,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::SurfaceKHR::from_raw(305398016_u64 as _)
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *mut vk::DeviceGroupPresentModeFlagsKHR,
					)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetDeviceGroupSurfacePresentModesKHR = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetDeviceGroupSurfacePresentModesKHR,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkGetDeviceGroupSurfacePresentModesKHR", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_device_group_surface_present_modes_khr(
					&fixture.device,
					vk::SurfaceKHR::from_raw(305398016_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::DeviceGroupPresentModeFlagsKHR
				),
				expected
			);
			assert_eq!(
				vk::Device::get_device_group_surface_present_modes_khr(
					&fixture.device,
					vk::SurfaceKHR::from_raw(305398016_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::DeviceGroupPresentModeFlagsKHR
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn acquire_next_image2_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::AcquireNextImageInfoKHR<'_>,
		*mut u32,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::acquire_next_image2_khr;
	let _: Signature = vk::Device::acquire_next_image2_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::acquire_next_image2_khr(
				&fixture.device,
				std::mem::zeroed::<*const vk::AcquireNextImageInfoKHR<'_>>(),
				std::mem::zeroed::<*mut u32>()
			),
			Err(CallError::MissingCommand("vkAcquireNextImage2KHR"))
		));
		assert!(matches!(
			fixture.device.acquire_next_image2_khr(
				std::mem::zeroed::<*const vk::AcquireNextImageInfoKHR<'_>>(),
				std::mem::zeroed::<*mut u32>()
			),
			Err(CallError::MissingCommand("vkAcquireNextImage2KHR"))
		));
	}
}

#[test]
fn acquire_next_image2_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::AcquireNextImageInfoKHR<'_>,
		arg_2: *mut u32,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::AcquireNextImageInfoKHR<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut u32,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkAcquireNextImage2KHR = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkAcquireNextImage2KHR, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkAcquireNextImage2KHR", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::acquire_next_image2_khr(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::AcquireNextImageInfoKHR<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut u32
				),
				expected
			);
			assert_eq!(
				vk::Device::acquire_next_image2_khr(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::AcquireNextImageInfoKHR<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut u32
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_dispatch_base_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		u32,
		u32,
		u32,
		u32,
		u32,
		u32,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_dispatch_base;
	let _: Signature = vk::Device::cmd_dispatch_base;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_dispatch_base(
				&fixture.device,
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default()
			),
			Err(CallError::MissingCommand("vkCmdDispatchBase"))
		));
		assert!(matches!(
			fixture.device.cmd_dispatch_base(
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default()
			),
			Err(CallError::MissingCommand("vkCmdDispatchBase"))
		));
	}
}

#[test]
fn cmd_dispatch_base_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		u32,
		u32,
		u32,
		u32,
		u32,
		u32,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_dispatch_base_khr;
	let _: Signature = vk::Device::cmd_dispatch_base_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_dispatch_base_khr(
				&fixture.device,
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default()
			),
			Err(CallError::MissingCommand("vkCmdDispatchBaseKHR"))
		));
		assert!(matches!(
			fixture.device.cmd_dispatch_base_khr(
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default()
			),
			Err(CallError::MissingCommand("vkCmdDispatchBaseKHR"))
		));
	}
}

#[test]
fn get_physical_device_present_rectangles_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		vk::PhysicalDevice,
		vk::SurfaceKHR,
		*mut u32,
		*mut vk::Rect2D,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_physical_device_present_rectangles_khr;
	let _: Signature = vk::Instance::get_physical_device_present_rectangles_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_physical_device_present_rectangles_khr(
				&fixture.instance,
				std::mem::zeroed::<vk::PhysicalDevice>(),
				std::mem::zeroed::<vk::SurfaceKHR>(),
				std::mem::zeroed::<*mut u32>(),
				std::mem::zeroed::<*mut vk::Rect2D>()
			),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDevicePresentRectanglesKHR"
			))
		));
		assert!(matches!(
			fixture.instance.get_physical_device_present_rectangles_khr(
				std::mem::zeroed::<vk::PhysicalDevice>(),
				std::mem::zeroed::<vk::SurfaceKHR>(),
				std::mem::zeroed::<*mut u32>(),
				std::mem::zeroed::<*mut vk::Rect2D>()
			),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDevicePresentRectanglesKHR"
			))
		));
	}
}

#[test]
fn get_physical_device_present_rectangles_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::PhysicalDevice,
		arg_1: vk::SurfaceKHR,
		arg_2: *mut u32,
		arg_3: *mut vk::Rect2D,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::PhysicalDevice::from_raw(305397760_u64 as _)
					&& arg_1 == vk::SurfaceKHR::from_raw(305398016_u64 as _)
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut u32,
					) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::Rect2D,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetPhysicalDevicePresentRectanglesKHR = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetPhysicalDevicePresentRectanglesKHR,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkGetPhysicalDevicePresentRectanglesKHR", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_physical_device_present_rectangles_khr(
					&fixture.instance,
					vk::PhysicalDevice::from_raw(305397760_u64 as _),
					vk::SurfaceKHR::from_raw(305398016_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut u32,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::Rect2D
				),
				expected
			);
			assert_eq!(
				vk::Instance::get_physical_device_present_rectangles_khr(
					&fixture.instance,
					vk::PhysicalDevice::from_raw(305397760_u64 as _),
					vk::SurfaceKHR::from_raw(305398016_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut u32,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::Rect2D
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn create_descriptor_update_template_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		&vk::DescriptorUpdateTemplateCreateInfo<'_>,
		Option<&vk::AllocationCallbacks>,
	) -> Result<vk::DescriptorUpdateTemplate, CallError>;
	let _: Signature = vk::create_descriptor_update_template;
	let _: Signature = vk::Device::create_descriptor_update_template;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::create_descriptor_update_template(
				&fixture.device,
				&std::mem::zeroed::<vk::DescriptorUpdateTemplateCreateInfo<'_>>(),
				None
			),
			Err(CallError::MissingCommand(
				"vkCreateDescriptorUpdateTemplate"
			))
		));
		assert!(matches!(
			fixture.device.create_descriptor_update_template(
				&std::mem::zeroed::<vk::DescriptorUpdateTemplateCreateInfo<'_>>(),
				None
			),
			Err(CallError::MissingCommand(
				"vkCreateDescriptorUpdateTemplate"
			))
		));
	}
}

#[test]
fn create_descriptor_update_template_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		&vk::DescriptorUpdateTemplateCreateInfo<'_>,
		Option<&vk::AllocationCallbacks>,
	) -> Result<vk::DescriptorUpdateTemplate, CallError>;
	let _: Signature = vk::create_descriptor_update_template_khr;
	let _: Signature = vk::Device::create_descriptor_update_template_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::create_descriptor_update_template_khr(
				&fixture.device,
				&std::mem::zeroed::<vk::DescriptorUpdateTemplateCreateInfo<'_>>(),
				None
			),
			Err(CallError::MissingCommand(
				"vkCreateDescriptorUpdateTemplateKHR"
			))
		));
		assert!(matches!(
			fixture.device.create_descriptor_update_template_khr(
				&std::mem::zeroed::<vk::DescriptorUpdateTemplateCreateInfo<'_>>(),
				None
			),
			Err(CallError::MissingCommand(
				"vkCreateDescriptorUpdateTemplateKHR"
			))
		));
	}
}

#[test]
fn destroy_descriptor_update_template_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::DescriptorUpdateTemplate,
		Option<&vk::AllocationCallbacks>,
	) -> Result<(), CallError>;
	let _: Signature = vk::destroy_descriptor_update_template;
	let _: Signature = vk::Device::destroy_descriptor_update_template;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::destroy_descriptor_update_template(&fixture.device, Default::default(), None),
			Err(CallError::MissingCommand(
				"vkDestroyDescriptorUpdateTemplate"
			))
		));
		assert!(matches!(
			fixture
				.device
				.destroy_descriptor_update_template(Default::default(), None),
			Err(CallError::MissingCommand(
				"vkDestroyDescriptorUpdateTemplate"
			))
		));
	}
}

#[test]
fn destroy_descriptor_update_template_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::DescriptorUpdateTemplate,
		Option<&vk::AllocationCallbacks>,
	) -> Result<(), CallError>;
	let _: Signature = vk::destroy_descriptor_update_template_khr;
	let _: Signature = vk::Device::destroy_descriptor_update_template_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::destroy_descriptor_update_template_khr(&fixture.device, Default::default(), None),
			Err(CallError::MissingCommand(
				"vkDestroyDescriptorUpdateTemplateKHR"
			))
		));
		assert!(matches!(
			fixture
				.device
				.destroy_descriptor_update_template_khr(Default::default(), None),
			Err(CallError::MissingCommand(
				"vkDestroyDescriptorUpdateTemplateKHR"
			))
		));
	}
}

#[test]
fn update_descriptor_set_with_template_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::DescriptorSet,
		vk::DescriptorUpdateTemplate,
		*const std::ffi::c_void,
	) -> Result<(), CallError>;
	let _: Signature = vk::update_descriptor_set_with_template;
	let _: Signature = vk::Device::update_descriptor_set_with_template;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::update_descriptor_set_with_template(
				&fixture.device,
				Default::default(),
				Default::default(),
				std::ptr::null()
			),
			Err(CallError::MissingCommand(
				"vkUpdateDescriptorSetWithTemplate"
			))
		));
		assert!(matches!(
			fixture.device.update_descriptor_set_with_template(
				Default::default(),
				Default::default(),
				std::ptr::null()
			),
			Err(CallError::MissingCommand(
				"vkUpdateDescriptorSetWithTemplate"
			))
		));
	}
}

#[test]
fn update_descriptor_set_with_template_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::DescriptorSet,
		vk::DescriptorUpdateTemplate,
		*const std::ffi::c_void,
	) -> Result<(), CallError>;
	let _: Signature = vk::update_descriptor_set_with_template_khr;
	let _: Signature = vk::Device::update_descriptor_set_with_template_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::update_descriptor_set_with_template_khr(
				&fixture.device,
				Default::default(),
				Default::default(),
				std::ptr::null()
			),
			Err(CallError::MissingCommand(
				"vkUpdateDescriptorSetWithTemplateKHR"
			))
		));
		assert!(matches!(
			fixture.device.update_descriptor_set_with_template_khr(
				Default::default(),
				Default::default(),
				std::ptr::null()
			),
			Err(CallError::MissingCommand(
				"vkUpdateDescriptorSetWithTemplateKHR"
			))
		));
	}
}

#[test]
fn cmd_push_descriptor_set_with_template_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		vk::DescriptorUpdateTemplate,
		vk::PipelineLayout,
		u32,
		*const std::ffi::c_void,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_push_descriptor_set_with_template;
	let _: Signature = vk::Device::cmd_push_descriptor_set_with_template;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_push_descriptor_set_with_template(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::DescriptorUpdateTemplate>(),
				std::mem::zeroed::<vk::PipelineLayout>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const std::ffi::c_void>()
			),
			Err(CallError::MissingCommand(
				"vkCmdPushDescriptorSetWithTemplate"
			))
		));
		assert!(matches!(
			fixture.device.cmd_push_descriptor_set_with_template(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::DescriptorUpdateTemplate>(),
				std::mem::zeroed::<vk::PipelineLayout>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const std::ffi::c_void>()
			),
			Err(CallError::MissingCommand(
				"vkCmdPushDescriptorSetWithTemplate"
			))
		));
	}
}

#[test]
fn cmd_push_descriptor_set_with_template_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: vk::DescriptorUpdateTemplate,
		arg_2: vk::PipelineLayout,
		arg_3: u32,
		arg_4: *const std::ffi::c_void,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == vk::DescriptorUpdateTemplate::from_raw(305398016_u64 as _)
					&& arg_2 == vk::PipelineLayout::from_raw(305398272_u64 as _)
					&& arg_3 == Default::default()
					&& std::ptr::eq(
						arg_4,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784)
							as *const std::ffi::c_void,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdPushDescriptorSetWithTemplate = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkCmdPushDescriptorSetWithTemplate,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdPushDescriptorSetWithTemplate", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_push_descriptor_set_with_template(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::DescriptorUpdateTemplate::from_raw(305398016_u64 as _),
			vk::PipelineLayout::from_raw(305398272_u64 as _),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784) as *const std::ffi::c_void,
		)
		.unwrap();
		vk::Device::cmd_push_descriptor_set_with_template(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::DescriptorUpdateTemplate::from_raw(305398016_u64 as _),
			vk::PipelineLayout::from_raw(305398272_u64 as _),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784) as *const std::ffi::c_void,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_push_descriptor_set_with_template_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		vk::DescriptorUpdateTemplate,
		vk::PipelineLayout,
		u32,
		*const std::ffi::c_void,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_push_descriptor_set_with_template_khr;
	let _: Signature = vk::Device::cmd_push_descriptor_set_with_template_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_push_descriptor_set_with_template_khr(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::DescriptorUpdateTemplate>(),
				std::mem::zeroed::<vk::PipelineLayout>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const std::ffi::c_void>()
			),
			Err(CallError::MissingCommand(
				"vkCmdPushDescriptorSetWithTemplateKHR"
			))
		));
		assert!(matches!(
			fixture.device.cmd_push_descriptor_set_with_template_khr(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::DescriptorUpdateTemplate>(),
				std::mem::zeroed::<vk::PipelineLayout>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const std::ffi::c_void>()
			),
			Err(CallError::MissingCommand(
				"vkCmdPushDescriptorSetWithTemplateKHR"
			))
		));
	}
}

#[test]
fn cmd_push_descriptor_set_with_template_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: vk::DescriptorUpdateTemplate,
		arg_2: vk::PipelineLayout,
		arg_3: u32,
		arg_4: *const std::ffi::c_void,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == vk::DescriptorUpdateTemplate::from_raw(305398016_u64 as _)
					&& arg_2 == vk::PipelineLayout::from_raw(305398272_u64 as _)
					&& arg_3 == Default::default()
					&& std::ptr::eq(
						arg_4,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784)
							as *const std::ffi::c_void,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdPushDescriptorSetWithTemplateKHR = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkCmdPushDescriptorSetWithTemplateKHR,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdPushDescriptorSetWithTemplateKHR", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_push_descriptor_set_with_template_khr(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::DescriptorUpdateTemplate::from_raw(305398016_u64 as _),
			vk::PipelineLayout::from_raw(305398272_u64 as _),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784) as *const std::ffi::c_void,
		)
		.unwrap();
		vk::Device::cmd_push_descriptor_set_with_template_khr(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::DescriptorUpdateTemplate::from_raw(305398016_u64 as _),
			vk::PipelineLayout::from_raw(305398272_u64 as _),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784) as *const std::ffi::c_void,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn set_hdr_metadata_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		u32,
		*const vk::SwapchainKHR,
		*const vk::HdrMetadataEXT<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::set_hdr_metadata_ext;
	let _: Signature = vk::Device::set_hdr_metadata_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::set_hdr_metadata_ext(
				&fixture.device,
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::SwapchainKHR>(),
				std::mem::zeroed::<*const vk::HdrMetadataEXT<'_>>()
			),
			Err(CallError::MissingCommand("vkSetHdrMetadataEXT"))
		));
		assert!(matches!(
			fixture.device.set_hdr_metadata_ext(
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::SwapchainKHR>(),
				std::mem::zeroed::<*const vk::HdrMetadataEXT<'_>>()
			),
			Err(CallError::MissingCommand("vkSetHdrMetadataEXT"))
		));
	}
}

#[test]
fn set_hdr_metadata_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: u32,
		arg_2: *const vk::SwapchainKHR,
		arg_3: *const vk::HdrMetadataEXT<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == Default::default()
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *const vk::SwapchainKHR,
					) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *const vk::HdrMetadataEXT<'_>,
				)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkSetHdrMetadataEXT = Some(mock);
		let erased = std::mem::transmute::<vk::PFN_vkSetHdrMetadataEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkSetHdrMetadataEXT", erased);
		let resolutions = Fixture::query_count();
		vk::set_hdr_metadata_ext(
			&fixture.device,
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *const vk::SwapchainKHR,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
				as *const vk::HdrMetadataEXT<'_>,
		)
		.unwrap();
		vk::Device::set_hdr_metadata_ext(
			&fixture.device,
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *const vk::SwapchainKHR,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
				as *const vk::HdrMetadataEXT<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_swapchain_status_khr_signature_and_missing_command() {
	type Signature = unsafe fn(&vk::Device, vk::SwapchainKHR) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_swapchain_status_khr;
	let _: Signature = vk::Device::get_swapchain_status_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_swapchain_status_khr(&fixture.device, std::mem::zeroed::<vk::SwapchainKHR>()),
			Err(CallError::MissingCommand("vkGetSwapchainStatusKHR"))
		));
		assert!(matches!(
			fixture
				.device
				.get_swapchain_status_khr(std::mem::zeroed::<vk::SwapchainKHR>()),
			Err(CallError::MissingCommand("vkGetSwapchainStatusKHR"))
		));
	}
}

#[test]
fn get_swapchain_status_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::DeviceHandle, arg_1: vk::SwapchainKHR) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::SwapchainKHR::from_raw(305398016_u64 as _)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetSwapchainStatusKHR = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkGetSwapchainStatusKHR, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkGetSwapchainStatusKHR", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_swapchain_status_khr(
					&fixture.device,
					vk::SwapchainKHR::from_raw(305398016_u64 as _)
				),
				expected
			);
			assert_eq!(
				vk::Device::get_swapchain_status_khr(
					&fixture.device,
					vk::SwapchainKHR::from_raw(305398016_u64 as _)
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_refresh_cycle_duration_google_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::SwapchainKHR,
		*mut vk::RefreshCycleDurationGOOGLE,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_refresh_cycle_duration_google;
	let _: Signature = vk::Device::get_refresh_cycle_duration_google;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_refresh_cycle_duration_google(
				&fixture.device,
				std::mem::zeroed::<vk::SwapchainKHR>(),
				std::mem::zeroed::<*mut vk::RefreshCycleDurationGOOGLE>()
			),
			Err(CallError::MissingCommand("vkGetRefreshCycleDurationGOOGLE"))
		));
		assert!(matches!(
			fixture.device.get_refresh_cycle_duration_google(
				std::mem::zeroed::<vk::SwapchainKHR>(),
				std::mem::zeroed::<*mut vk::RefreshCycleDurationGOOGLE>()
			),
			Err(CallError::MissingCommand("vkGetRefreshCycleDurationGOOGLE"))
		));
	}
}

#[test]
fn get_refresh_cycle_duration_google_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::SwapchainKHR,
		arg_2: *mut vk::RefreshCycleDurationGOOGLE,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::SwapchainKHR::from_raw(305398016_u64 as _)
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *mut vk::RefreshCycleDurationGOOGLE,
					)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetRefreshCycleDurationGOOGLE = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkGetRefreshCycleDurationGOOGLE, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkGetRefreshCycleDurationGOOGLE", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_refresh_cycle_duration_google(
					&fixture.device,
					vk::SwapchainKHR::from_raw(305398016_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::RefreshCycleDurationGOOGLE
				),
				expected
			);
			assert_eq!(
				vk::Device::get_refresh_cycle_duration_google(
					&fixture.device,
					vk::SwapchainKHR::from_raw(305398016_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::RefreshCycleDurationGOOGLE
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_past_presentation_timing_google_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::SwapchainKHR,
		*mut u32,
		*mut vk::PastPresentationTimingGOOGLE,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_past_presentation_timing_google;
	let _: Signature = vk::Device::get_past_presentation_timing_google;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_past_presentation_timing_google(
				&fixture.device,
				std::mem::zeroed::<vk::SwapchainKHR>(),
				std::mem::zeroed::<*mut u32>(),
				std::mem::zeroed::<*mut vk::PastPresentationTimingGOOGLE>()
			),
			Err(CallError::MissingCommand(
				"vkGetPastPresentationTimingGOOGLE"
			))
		));
		assert!(matches!(
			fixture.device.get_past_presentation_timing_google(
				std::mem::zeroed::<vk::SwapchainKHR>(),
				std::mem::zeroed::<*mut u32>(),
				std::mem::zeroed::<*mut vk::PastPresentationTimingGOOGLE>()
			),
			Err(CallError::MissingCommand(
				"vkGetPastPresentationTimingGOOGLE"
			))
		));
	}
}

#[test]
fn get_past_presentation_timing_google_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::SwapchainKHR,
		arg_2: *mut u32,
		arg_3: *mut vk::PastPresentationTimingGOOGLE,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::SwapchainKHR::from_raw(305398016_u64 as _)
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut u32,
					) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::PastPresentationTimingGOOGLE,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetPastPresentationTimingGOOGLE = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetPastPresentationTimingGOOGLE,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkGetPastPresentationTimingGOOGLE", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_past_presentation_timing_google(
					&fixture.device,
					vk::SwapchainKHR::from_raw(305398016_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut u32,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::PastPresentationTimingGOOGLE
				),
				expected
			);
			assert_eq!(
				vk::Device::get_past_presentation_timing_google(
					&fixture.device,
					vk::SwapchainKHR::from_raw(305398016_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut u32,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::PastPresentationTimingGOOGLE
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[cfg(feature = "platform-ios")]
#[test]
fn create_ios_surface_mvk_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		*const vk::IOSSurfaceCreateInfoMVK<'_>,
		*const vk::AllocationCallbacks,
		*mut vk::SurfaceKHR,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::create_ios_surface_mvk;
	let _: Signature = vk::Instance::create_ios_surface_mvk;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::create_ios_surface_mvk(
				&fixture.instance,
				std::mem::zeroed::<*const vk::IOSSurfaceCreateInfoMVK<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::SurfaceKHR>()
			),
			Err(CallError::MissingCommand("vkCreateIOSSurfaceMVK"))
		));
		assert!(matches!(
			fixture.instance.create_ios_surface_mvk(
				std::mem::zeroed::<*const vk::IOSSurfaceCreateInfoMVK<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::SurfaceKHR>()
			),
			Err(CallError::MissingCommand("vkCreateIOSSurfaceMVK"))
		));
	}
}

#[cfg(feature = "platform-ios")]
#[test]
fn create_ios_surface_mvk_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::InstanceHandle,
		arg_1: *const vk::IOSSurfaceCreateInfoMVK<'_>,
		arg_2: *const vk::AllocationCallbacks,
		arg_3: *mut vk::SurfaceKHR,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::InstanceHandle::from_raw(0x1000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::IOSSurfaceCreateInfoMVK<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
				) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::SurfaceKHR,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCreateIOSSurfaceMVK = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCreateIOSSurfaceMVK, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCreateIOSSurfaceMVK", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::create_ios_surface_mvk(
					&fixture.instance,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::IOSSurfaceCreateInfoMVK<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::SurfaceKHR
				),
				expected
			);
			assert_eq!(
				vk::Instance::create_ios_surface_mvk(
					&fixture.instance,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::IOSSurfaceCreateInfoMVK<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::SurfaceKHR
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[cfg(feature = "platform-macos")]
#[test]
fn create_mac_os_surface_mvk_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		*const vk::MacOSSurfaceCreateInfoMVK<'_>,
		*const vk::AllocationCallbacks,
		*mut vk::SurfaceKHR,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::create_mac_os_surface_mvk;
	let _: Signature = vk::Instance::create_mac_os_surface_mvk;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::create_mac_os_surface_mvk(
				&fixture.instance,
				std::mem::zeroed::<*const vk::MacOSSurfaceCreateInfoMVK<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::SurfaceKHR>()
			),
			Err(CallError::MissingCommand("vkCreateMacOSSurfaceMVK"))
		));
		assert!(matches!(
			fixture.instance.create_mac_os_surface_mvk(
				std::mem::zeroed::<*const vk::MacOSSurfaceCreateInfoMVK<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::SurfaceKHR>()
			),
			Err(CallError::MissingCommand("vkCreateMacOSSurfaceMVK"))
		));
	}
}

#[cfg(feature = "platform-macos")]
#[test]
fn create_mac_os_surface_mvk_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::InstanceHandle,
		arg_1: *const vk::MacOSSurfaceCreateInfoMVK<'_>,
		arg_2: *const vk::AllocationCallbacks,
		arg_3: *mut vk::SurfaceKHR,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::InstanceHandle::from_raw(0x1000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::MacOSSurfaceCreateInfoMVK<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
				) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::SurfaceKHR,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCreateMacOSSurfaceMVK = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCreateMacOSSurfaceMVK, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCreateMacOSSurfaceMVK", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::create_mac_os_surface_mvk(
					&fixture.instance,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::MacOSSurfaceCreateInfoMVK<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::SurfaceKHR
				),
				expected
			);
			assert_eq!(
				vk::Instance::create_mac_os_surface_mvk(
					&fixture.instance,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::MacOSSurfaceCreateInfoMVK<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::SurfaceKHR
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[cfg(feature = "platform-metal")]
#[test]
fn create_metal_surface_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		*const vk::MetalSurfaceCreateInfoEXT<'_>,
		*const vk::AllocationCallbacks,
		*mut vk::SurfaceKHR,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::create_metal_surface_ext;
	let _: Signature = vk::Instance::create_metal_surface_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::create_metal_surface_ext(
				&fixture.instance,
				std::mem::zeroed::<*const vk::MetalSurfaceCreateInfoEXT<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::SurfaceKHR>()
			),
			Err(CallError::MissingCommand("vkCreateMetalSurfaceEXT"))
		));
		assert!(matches!(
			fixture.instance.create_metal_surface_ext(
				std::mem::zeroed::<*const vk::MetalSurfaceCreateInfoEXT<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::SurfaceKHR>()
			),
			Err(CallError::MissingCommand("vkCreateMetalSurfaceEXT"))
		));
	}
}

#[cfg(feature = "platform-metal")]
#[test]
fn create_metal_surface_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::InstanceHandle,
		arg_1: *const vk::MetalSurfaceCreateInfoEXT<'_>,
		arg_2: *const vk::AllocationCallbacks,
		arg_3: *mut vk::SurfaceKHR,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::InstanceHandle::from_raw(0x1000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::MetalSurfaceCreateInfoEXT<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
				) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::SurfaceKHR,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCreateMetalSurfaceEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCreateMetalSurfaceEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCreateMetalSurfaceEXT", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::create_metal_surface_ext(
					&fixture.instance,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::MetalSurfaceCreateInfoEXT<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::SurfaceKHR
				),
				expected
			);
			assert_eq!(
				vk::Instance::create_metal_surface_ext(
					&fixture.instance,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::MetalSurfaceCreateInfoEXT<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::SurfaceKHR
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_set_viewport_w_scaling_nv_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		u32,
		u32,
		*const vk::ViewportWScalingNV,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_viewport_w_scaling_nv;
	let _: Signature = vk::Device::cmd_set_viewport_w_scaling_nv;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_viewport_w_scaling_nv(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::ViewportWScalingNV>()
			),
			Err(CallError::MissingCommand("vkCmdSetViewportWScalingNV"))
		));
		assert!(matches!(
			fixture.device.cmd_set_viewport_w_scaling_nv(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::ViewportWScalingNV>()
			),
			Err(CallError::MissingCommand("vkCmdSetViewportWScalingNV"))
		));
	}
}

#[test]
fn cmd_set_viewport_w_scaling_nv_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: u32,
		arg_2: u32,
		arg_3: *const vk::ViewportWScalingNV,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == Default::default()
					&& arg_2 == Default::default()
					&& std::ptr::eq(
						arg_3,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
							as *const vk::ViewportWScalingNV,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdSetViewportWScalingNV = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdSetViewportWScalingNV, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdSetViewportWScalingNV", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_set_viewport_w_scaling_nv(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
				as *const vk::ViewportWScalingNV,
		)
		.unwrap();
		vk::Device::cmd_set_viewport_w_scaling_nv(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
				as *const vk::ViewportWScalingNV,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_set_discard_rectangle_ext_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, vk::CommandBuffer, u32, u32, *const vk::Rect2D) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_discard_rectangle_ext;
	let _: Signature = vk::Device::cmd_set_discard_rectangle_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_discard_rectangle_ext(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::Rect2D>()
			),
			Err(CallError::MissingCommand("vkCmdSetDiscardRectangleEXT"))
		));
		assert!(matches!(
			fixture.device.cmd_set_discard_rectangle_ext(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::Rect2D>()
			),
			Err(CallError::MissingCommand("vkCmdSetDiscardRectangleEXT"))
		));
	}
}

#[test]
fn cmd_set_discard_rectangle_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: u32,
		arg_2: u32,
		arg_3: *const vk::Rect2D,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == Default::default()
					&& arg_2 == Default::default()
					&& std::ptr::eq(
						arg_3,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *const vk::Rect2D,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdSetDiscardRectangleEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdSetDiscardRectangleEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdSetDiscardRectangleEXT", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_set_discard_rectangle_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *const vk::Rect2D,
		)
		.unwrap();
		vk::Device::cmd_set_discard_rectangle_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *const vk::Rect2D,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_set_discard_rectangle_enable_ext_signature_and_missing_command() {
	type Signature = unsafe fn(&vk::Device, vk::CommandBuffer, vk::Bool32) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_discard_rectangle_enable_ext;
	let _: Signature = vk::Device::cmd_set_discard_rectangle_enable_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_discard_rectangle_enable_ext(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::Bool32>()
			),
			Err(CallError::MissingCommand(
				"vkCmdSetDiscardRectangleEnableEXT"
			))
		));
		assert!(matches!(
			fixture.device.cmd_set_discard_rectangle_enable_ext(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::Bool32>()
			),
			Err(CallError::MissingCommand(
				"vkCmdSetDiscardRectangleEnableEXT"
			))
		));
	}
}

#[test]
fn cmd_set_discard_rectangle_enable_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::CommandBuffer, arg_1: vk::Bool32) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == 305398016_u64 as vk::Bool32),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdSetDiscardRectangleEnableEXT = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkCmdSetDiscardRectangleEnableEXT,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdSetDiscardRectangleEnableEXT", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_set_discard_rectangle_enable_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			305398016_u64 as vk::Bool32,
		)
		.unwrap();
		vk::Device::cmd_set_discard_rectangle_enable_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			305398016_u64 as vk::Bool32,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_set_discard_rectangle_mode_ext_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, vk::CommandBuffer, vk::DiscardRectangleModeEXT) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_discard_rectangle_mode_ext;
	let _: Signature = vk::Device::cmd_set_discard_rectangle_mode_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_discard_rectangle_mode_ext(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::DiscardRectangleModeEXT>()
			),
			Err(CallError::MissingCommand("vkCmdSetDiscardRectangleModeEXT"))
		));
		assert!(matches!(
			fixture.device.cmd_set_discard_rectangle_mode_ext(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::DiscardRectangleModeEXT>()
			),
			Err(CallError::MissingCommand("vkCmdSetDiscardRectangleModeEXT"))
		));
	}
}

#[test]
fn cmd_set_discard_rectangle_mode_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::CommandBuffer, arg_1: vk::DiscardRectangleModeEXT) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == vk::DiscardRectangleModeEXT::from_raw(305398016_u64 as _)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdSetDiscardRectangleModeEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdSetDiscardRectangleModeEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdSetDiscardRectangleModeEXT", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_set_discard_rectangle_mode_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::DiscardRectangleModeEXT::from_raw(305398016_u64 as _),
		)
		.unwrap();
		vk::Device::cmd_set_discard_rectangle_mode_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::DiscardRectangleModeEXT::from_raw(305398016_u64 as _),
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_set_sample_locations_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		*const vk::SampleLocationsInfoEXT<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_sample_locations_ext;
	let _: Signature = vk::Device::cmd_set_sample_locations_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_sample_locations_ext(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::SampleLocationsInfoEXT<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdSetSampleLocationsEXT"))
		));
		assert!(matches!(
			fixture.device.cmd_set_sample_locations_ext(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::SampleLocationsInfoEXT<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdSetSampleLocationsEXT"))
		));
	}
}

#[test]
fn cmd_set_sample_locations_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: *const vk::SampleLocationsInfoEXT<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::SampleLocationsInfoEXT<'_>,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdSetSampleLocationsEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdSetSampleLocationsEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdSetSampleLocationsEXT", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_set_sample_locations_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::SampleLocationsInfoEXT<'_>,
		)
		.unwrap();
		vk::Device::cmd_set_sample_locations_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::SampleLocationsInfoEXT<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_physical_device_multisample_properties_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		vk::PhysicalDevice,
		vk::SampleCountFlagBits,
		*mut vk::MultisamplePropertiesEXT<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::get_physical_device_multisample_properties_ext;
	let _: Signature = vk::Instance::get_physical_device_multisample_properties_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_physical_device_multisample_properties_ext(
				&fixture.instance,
				std::mem::zeroed::<vk::PhysicalDevice>(),
				std::mem::zeroed::<vk::SampleCountFlagBits>(),
				std::mem::zeroed::<*mut vk::MultisamplePropertiesEXT<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceMultisamplePropertiesEXT"
			))
		));
		assert!(matches!(
			fixture
				.instance
				.get_physical_device_multisample_properties_ext(
					std::mem::zeroed::<vk::PhysicalDevice>(),
					std::mem::zeroed::<vk::SampleCountFlagBits>(),
					std::mem::zeroed::<*mut vk::MultisamplePropertiesEXT<'_>>()
				),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceMultisamplePropertiesEXT"
			))
		));
	}
}

#[test]
fn get_physical_device_multisample_properties_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::PhysicalDevice,
		arg_1: vk::SampleCountFlagBits,
		arg_2: *mut vk::MultisamplePropertiesEXT<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::PhysicalDevice::from_raw(305397760_u64 as _)
					&& arg_1 == vk::SampleCountFlagBits::from_raw(305398016_u64 as _)
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *mut vk::MultisamplePropertiesEXT<'_>,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkGetPhysicalDeviceMultisamplePropertiesEXT", erased);
		let resolutions = Fixture::query_count();
		vk::get_physical_device_multisample_properties_ext(
			&fixture.instance,
			vk::PhysicalDevice::from_raw(305397760_u64 as _),
			vk::SampleCountFlagBits::from_raw(305398016_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *mut vk::MultisamplePropertiesEXT<'_>,
		)
		.unwrap();
		vk::Instance::get_physical_device_multisample_properties_ext(
			&fixture.instance,
			vk::PhysicalDevice::from_raw(305397760_u64 as _),
			vk::SampleCountFlagBits::from_raw(305398016_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *mut vk::MultisamplePropertiesEXT<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_physical_device_surface_capabilities2_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		vk::PhysicalDevice,
		*const vk::PhysicalDeviceSurfaceInfo2KHR<'_>,
		*mut vk::SurfaceCapabilities2KHR<'_>,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_physical_device_surface_capabilities2_khr;
	let _: Signature = vk::Instance::get_physical_device_surface_capabilities2_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_physical_device_surface_capabilities2_khr(
				&fixture.instance,
				std::mem::zeroed::<vk::PhysicalDevice>(),
				std::mem::zeroed::<*const vk::PhysicalDeviceSurfaceInfo2KHR<'_>>(),
				std::mem::zeroed::<*mut vk::SurfaceCapabilities2KHR<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceSurfaceCapabilities2KHR"
			))
		));
		assert!(matches!(
			fixture
				.instance
				.get_physical_device_surface_capabilities2_khr(
					std::mem::zeroed::<vk::PhysicalDevice>(),
					std::mem::zeroed::<*const vk::PhysicalDeviceSurfaceInfo2KHR<'_>>(),
					std::mem::zeroed::<*mut vk::SurfaceCapabilities2KHR<'_>>()
				),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceSurfaceCapabilities2KHR"
			))
		));
	}
}

#[test]
fn get_physical_device_surface_capabilities2_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::PhysicalDevice,
		arg_1: *const vk::PhysicalDeviceSurfaceInfo2KHR<'_>,
		arg_2: *mut vk::SurfaceCapabilities2KHR<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::PhysicalDevice::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::PhysicalDeviceSurfaceInfo2KHR<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::SurfaceCapabilities2KHR<'_>,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkGetPhysicalDeviceSurfaceCapabilities2KHR", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_physical_device_surface_capabilities2_khr(
					&fixture.instance,
					vk::PhysicalDevice::from_raw(305397760_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::PhysicalDeviceSurfaceInfo2KHR<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::SurfaceCapabilities2KHR<'_>
				),
				expected
			);
			assert_eq!(
				vk::Instance::get_physical_device_surface_capabilities2_khr(
					&fixture.instance,
					vk::PhysicalDevice::from_raw(305397760_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::PhysicalDeviceSurfaceInfo2KHR<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::SurfaceCapabilities2KHR<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_physical_device_surface_formats2_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		vk::PhysicalDevice,
		*const vk::PhysicalDeviceSurfaceInfo2KHR<'_>,
		*mut u32,
		*mut vk::SurfaceFormat2KHR<'_>,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_physical_device_surface_formats2_khr;
	let _: Signature = vk::Instance::get_physical_device_surface_formats2_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_physical_device_surface_formats2_khr(
				&fixture.instance,
				std::mem::zeroed::<vk::PhysicalDevice>(),
				std::mem::zeroed::<*const vk::PhysicalDeviceSurfaceInfo2KHR<'_>>(),
				std::mem::zeroed::<*mut u32>(),
				std::mem::zeroed::<*mut vk::SurfaceFormat2KHR<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceSurfaceFormats2KHR"
			))
		));
		assert!(matches!(
			fixture.instance.get_physical_device_surface_formats2_khr(
				std::mem::zeroed::<vk::PhysicalDevice>(),
				std::mem::zeroed::<*const vk::PhysicalDeviceSurfaceInfo2KHR<'_>>(),
				std::mem::zeroed::<*mut u32>(),
				std::mem::zeroed::<*mut vk::SurfaceFormat2KHR<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceSurfaceFormats2KHR"
			))
		));
	}
}

#[test]
fn get_physical_device_surface_formats2_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::PhysicalDevice,
		arg_1: *const vk::PhysicalDeviceSurfaceInfo2KHR<'_>,
		arg_2: *mut u32,
		arg_3: *mut vk::SurfaceFormat2KHR<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::PhysicalDevice::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::PhysicalDeviceSurfaceInfo2KHR<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut u32,
				) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::SurfaceFormat2KHR<'_>,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetPhysicalDeviceSurfaceFormats2KHR = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetPhysicalDeviceSurfaceFormats2KHR,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkGetPhysicalDeviceSurfaceFormats2KHR", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_physical_device_surface_formats2_khr(
					&fixture.instance,
					vk::PhysicalDevice::from_raw(305397760_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::PhysicalDeviceSurfaceInfo2KHR<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut u32,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::SurfaceFormat2KHR<'_>
				),
				expected
			);
			assert_eq!(
				vk::Instance::get_physical_device_surface_formats2_khr(
					&fixture.instance,
					vk::PhysicalDevice::from_raw(305397760_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::PhysicalDeviceSurfaceInfo2KHR<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut u32,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::SurfaceFormat2KHR<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_physical_device_display_properties2_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		vk::PhysicalDevice,
		*mut u32,
		*mut vk::DisplayProperties2KHR<'_>,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_physical_device_display_properties2_khr;
	let _: Signature = vk::Instance::get_physical_device_display_properties2_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_physical_device_display_properties2_khr(
				&fixture.instance,
				std::mem::zeroed::<vk::PhysicalDevice>(),
				std::mem::zeroed::<*mut u32>(),
				std::mem::zeroed::<*mut vk::DisplayProperties2KHR<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceDisplayProperties2KHR"
			))
		));
		assert!(matches!(
			fixture
				.instance
				.get_physical_device_display_properties2_khr(
					std::mem::zeroed::<vk::PhysicalDevice>(),
					std::mem::zeroed::<*mut u32>(),
					std::mem::zeroed::<*mut vk::DisplayProperties2KHR<'_>>()
				),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceDisplayProperties2KHR"
			))
		));
	}
}

#[test]
fn get_physical_device_display_properties2_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::PhysicalDevice,
		arg_1: *mut u32,
		arg_2: *mut vk::DisplayProperties2KHR<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::PhysicalDevice::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016) as *mut u32,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::DisplayProperties2KHR<'_>,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetPhysicalDeviceDisplayProperties2KHR = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetPhysicalDeviceDisplayProperties2KHR,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkGetPhysicalDeviceDisplayProperties2KHR", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_physical_device_display_properties2_khr(
					&fixture.instance,
					vk::PhysicalDevice::from_raw(305397760_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016) as *mut u32,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::DisplayProperties2KHR<'_>
				),
				expected
			);
			assert_eq!(
				vk::Instance::get_physical_device_display_properties2_khr(
					&fixture.instance,
					vk::PhysicalDevice::from_raw(305397760_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016) as *mut u32,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::DisplayProperties2KHR<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_physical_device_display_plane_properties2_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		vk::PhysicalDevice,
		*mut u32,
		*mut vk::DisplayPlaneProperties2KHR<'_>,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_physical_device_display_plane_properties2_khr;
	let _: Signature = vk::Instance::get_physical_device_display_plane_properties2_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_physical_device_display_plane_properties2_khr(
				&fixture.instance,
				std::mem::zeroed::<vk::PhysicalDevice>(),
				std::mem::zeroed::<*mut u32>(),
				std::mem::zeroed::<*mut vk::DisplayPlaneProperties2KHR<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceDisplayPlaneProperties2KHR"
			))
		));
		assert!(matches!(
			fixture
				.instance
				.get_physical_device_display_plane_properties2_khr(
					std::mem::zeroed::<vk::PhysicalDevice>(),
					std::mem::zeroed::<*mut u32>(),
					std::mem::zeroed::<*mut vk::DisplayPlaneProperties2KHR<'_>>()
				),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceDisplayPlaneProperties2KHR"
			))
		));
	}
}

#[test]
fn get_physical_device_display_plane_properties2_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::PhysicalDevice,
		arg_1: *mut u32,
		arg_2: *mut vk::DisplayPlaneProperties2KHR<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::PhysicalDevice::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016) as *mut u32,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::DisplayPlaneProperties2KHR<'_>,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture =
			Fixture::new_with_command(c"vkGetPhysicalDeviceDisplayPlaneProperties2KHR", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_physical_device_display_plane_properties2_khr(
					&fixture.instance,
					vk::PhysicalDevice::from_raw(305397760_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016) as *mut u32,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::DisplayPlaneProperties2KHR<'_>
				),
				expected
			);
			assert_eq!(
				vk::Instance::get_physical_device_display_plane_properties2_khr(
					&fixture.instance,
					vk::PhysicalDevice::from_raw(305397760_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016) as *mut u32,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::DisplayPlaneProperties2KHR<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_display_mode_properties2_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		vk::PhysicalDevice,
		vk::DisplayKHR,
		*mut u32,
		*mut vk::DisplayModeProperties2KHR<'_>,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_display_mode_properties2_khr;
	let _: Signature = vk::Instance::get_display_mode_properties2_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_display_mode_properties2_khr(
				&fixture.instance,
				std::mem::zeroed::<vk::PhysicalDevice>(),
				std::mem::zeroed::<vk::DisplayKHR>(),
				std::mem::zeroed::<*mut u32>(),
				std::mem::zeroed::<*mut vk::DisplayModeProperties2KHR<'_>>()
			),
			Err(CallError::MissingCommand("vkGetDisplayModeProperties2KHR"))
		));
		assert!(matches!(
			fixture.instance.get_display_mode_properties2_khr(
				std::mem::zeroed::<vk::PhysicalDevice>(),
				std::mem::zeroed::<vk::DisplayKHR>(),
				std::mem::zeroed::<*mut u32>(),
				std::mem::zeroed::<*mut vk::DisplayModeProperties2KHR<'_>>()
			),
			Err(CallError::MissingCommand("vkGetDisplayModeProperties2KHR"))
		));
	}
}

#[test]
fn get_display_mode_properties2_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::PhysicalDevice,
		arg_1: vk::DisplayKHR,
		arg_2: *mut u32,
		arg_3: *mut vk::DisplayModeProperties2KHR<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::PhysicalDevice::from_raw(305397760_u64 as _)
					&& arg_1 == vk::DisplayKHR::from_raw(305398016_u64 as _)
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut u32,
					) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::DisplayModeProperties2KHR<'_>,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetDisplayModeProperties2KHR = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkGetDisplayModeProperties2KHR, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkGetDisplayModeProperties2KHR", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_display_mode_properties2_khr(
					&fixture.instance,
					vk::PhysicalDevice::from_raw(305397760_u64 as _),
					vk::DisplayKHR::from_raw(305398016_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut u32,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::DisplayModeProperties2KHR<'_>
				),
				expected
			);
			assert_eq!(
				vk::Instance::get_display_mode_properties2_khr(
					&fixture.instance,
					vk::PhysicalDevice::from_raw(305397760_u64 as _),
					vk::DisplayKHR::from_raw(305398016_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut u32,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::DisplayModeProperties2KHR<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_display_plane_capabilities2_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		vk::PhysicalDevice,
		*const vk::DisplayPlaneInfo2KHR<'_>,
		*mut vk::DisplayPlaneCapabilities2KHR<'_>,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_display_plane_capabilities2_khr;
	let _: Signature = vk::Instance::get_display_plane_capabilities2_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_display_plane_capabilities2_khr(
				&fixture.instance,
				std::mem::zeroed::<vk::PhysicalDevice>(),
				std::mem::zeroed::<*const vk::DisplayPlaneInfo2KHR<'_>>(),
				std::mem::zeroed::<*mut vk::DisplayPlaneCapabilities2KHR<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetDisplayPlaneCapabilities2KHR"
			))
		));
		assert!(matches!(
			fixture.instance.get_display_plane_capabilities2_khr(
				std::mem::zeroed::<vk::PhysicalDevice>(),
				std::mem::zeroed::<*const vk::DisplayPlaneInfo2KHR<'_>>(),
				std::mem::zeroed::<*mut vk::DisplayPlaneCapabilities2KHR<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetDisplayPlaneCapabilities2KHR"
			))
		));
	}
}

#[test]
fn get_display_plane_capabilities2_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::PhysicalDevice,
		arg_1: *const vk::DisplayPlaneInfo2KHR<'_>,
		arg_2: *mut vk::DisplayPlaneCapabilities2KHR<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::PhysicalDevice::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::DisplayPlaneInfo2KHR<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::DisplayPlaneCapabilities2KHR<'_>,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetDisplayPlaneCapabilities2KHR = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetDisplayPlaneCapabilities2KHR,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkGetDisplayPlaneCapabilities2KHR", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_display_plane_capabilities2_khr(
					&fixture.instance,
					vk::PhysicalDevice::from_raw(305397760_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::DisplayPlaneInfo2KHR<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::DisplayPlaneCapabilities2KHR<'_>
				),
				expected
			);
			assert_eq!(
				vk::Instance::get_display_plane_capabilities2_khr(
					&fixture.instance,
					vk::PhysicalDevice::from_raw(305397760_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::DisplayPlaneInfo2KHR<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::DisplayPlaneCapabilities2KHR<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_buffer_memory_requirements2_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		&vk::BufferMemoryRequirementsInfo2<'_>,
		&mut vk::MemoryRequirements2<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::get_buffer_memory_requirements2;
	let _: Signature = vk::Device::get_buffer_memory_requirements2;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_buffer_memory_requirements2(
				&fixture.device,
				&std::mem::zeroed::<vk::BufferMemoryRequirementsInfo2<'_>>(),
				&mut std::mem::zeroed::<vk::MemoryRequirements2<'_>>()
			),
			Err(CallError::MissingCommand("vkGetBufferMemoryRequirements2"))
		));
		assert!(matches!(
			fixture.device.get_buffer_memory_requirements2(
				&std::mem::zeroed::<vk::BufferMemoryRequirementsInfo2<'_>>(),
				&mut std::mem::zeroed::<vk::MemoryRequirements2<'_>>()
			),
			Err(CallError::MissingCommand("vkGetBufferMemoryRequirements2"))
		));
	}
}

#[test]
fn get_buffer_memory_requirements2_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		&vk::BufferMemoryRequirementsInfo2<'_>,
		&mut vk::MemoryRequirements2<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::get_buffer_memory_requirements2_khr;
	let _: Signature = vk::Device::get_buffer_memory_requirements2_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_buffer_memory_requirements2_khr(
				&fixture.device,
				&std::mem::zeroed::<vk::BufferMemoryRequirementsInfo2<'_>>(),
				&mut std::mem::zeroed::<vk::MemoryRequirements2<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetBufferMemoryRequirements2KHR"
			))
		));
		assert!(matches!(
			fixture.device.get_buffer_memory_requirements2_khr(
				&std::mem::zeroed::<vk::BufferMemoryRequirementsInfo2<'_>>(),
				&mut std::mem::zeroed::<vk::MemoryRequirements2<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetBufferMemoryRequirements2KHR"
			))
		));
	}
}

#[test]
fn get_image_memory_requirements2_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		&vk::ImageMemoryRequirementsInfo2<'_>,
		&mut vk::MemoryRequirements2<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::get_image_memory_requirements2;
	let _: Signature = vk::Device::get_image_memory_requirements2;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_image_memory_requirements2(
				&fixture.device,
				&std::mem::zeroed::<vk::ImageMemoryRequirementsInfo2<'_>>(),
				&mut std::mem::zeroed::<vk::MemoryRequirements2<'_>>()
			),
			Err(CallError::MissingCommand("vkGetImageMemoryRequirements2"))
		));
		assert!(matches!(
			fixture.device.get_image_memory_requirements2(
				&std::mem::zeroed::<vk::ImageMemoryRequirementsInfo2<'_>>(),
				&mut std::mem::zeroed::<vk::MemoryRequirements2<'_>>()
			),
			Err(CallError::MissingCommand("vkGetImageMemoryRequirements2"))
		));
	}
}

#[test]
fn get_image_memory_requirements2_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		&vk::ImageMemoryRequirementsInfo2<'_>,
		&mut vk::MemoryRequirements2<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::get_image_memory_requirements2_khr;
	let _: Signature = vk::Device::get_image_memory_requirements2_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_image_memory_requirements2_khr(
				&fixture.device,
				&std::mem::zeroed::<vk::ImageMemoryRequirementsInfo2<'_>>(),
				&mut std::mem::zeroed::<vk::MemoryRequirements2<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetImageMemoryRequirements2KHR"
			))
		));
		assert!(matches!(
			fixture.device.get_image_memory_requirements2_khr(
				&std::mem::zeroed::<vk::ImageMemoryRequirementsInfo2<'_>>(),
				&mut std::mem::zeroed::<vk::MemoryRequirements2<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetImageMemoryRequirements2KHR"
			))
		));
	}
}

#[test]
fn get_image_sparse_memory_requirements2_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		&vk::ImageSparseMemoryRequirementsInfo2<'_>,
		&mut u32,
		Option<&mut [vk::SparseImageMemoryRequirements2<'_>]>,
	) -> Result<(), CallError>;
	let _: Signature = vk::get_image_sparse_memory_requirements2;
	let _: Signature = vk::Device::get_image_sparse_memory_requirements2;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_image_sparse_memory_requirements2(
				&fixture.device,
				&std::mem::zeroed::<vk::ImageSparseMemoryRequirementsInfo2<'_>>(),
				&mut 0,
				None
			),
			Err(CallError::MissingCommand(
				"vkGetImageSparseMemoryRequirements2"
			))
		));
		assert!(matches!(
			fixture.device.get_image_sparse_memory_requirements2(
				&std::mem::zeroed::<vk::ImageSparseMemoryRequirementsInfo2<'_>>(),
				&mut 0,
				None
			),
			Err(CallError::MissingCommand(
				"vkGetImageSparseMemoryRequirements2"
			))
		));
	}
}

#[test]
fn get_image_sparse_memory_requirements2_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		&vk::ImageSparseMemoryRequirementsInfo2<'_>,
		&mut u32,
		Option<&mut [vk::SparseImageMemoryRequirements2<'_>]>,
	) -> Result<(), CallError>;
	let _: Signature = vk::get_image_sparse_memory_requirements2_khr;
	let _: Signature = vk::Device::get_image_sparse_memory_requirements2_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_image_sparse_memory_requirements2_khr(
				&fixture.device,
				&std::mem::zeroed::<vk::ImageSparseMemoryRequirementsInfo2<'_>>(),
				&mut 0,
				None
			),
			Err(CallError::MissingCommand(
				"vkGetImageSparseMemoryRequirements2KHR"
			))
		));
		assert!(matches!(
			fixture.device.get_image_sparse_memory_requirements2_khr(
				&std::mem::zeroed::<vk::ImageSparseMemoryRequirementsInfo2<'_>>(),
				&mut 0,
				None
			),
			Err(CallError::MissingCommand(
				"vkGetImageSparseMemoryRequirements2KHR"
			))
		));
	}
}

#[test]
fn get_device_buffer_memory_requirements_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::DeviceBufferMemoryRequirements<'_>,
		*mut vk::MemoryRequirements2<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::get_device_buffer_memory_requirements;
	let _: Signature = vk::Device::get_device_buffer_memory_requirements;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_device_buffer_memory_requirements(
				&fixture.device,
				std::mem::zeroed::<*const vk::DeviceBufferMemoryRequirements<'_>>(),
				std::mem::zeroed::<*mut vk::MemoryRequirements2<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetDeviceBufferMemoryRequirements"
			))
		));
		assert!(matches!(
			fixture.device.get_device_buffer_memory_requirements(
				std::mem::zeroed::<*const vk::DeviceBufferMemoryRequirements<'_>>(),
				std::mem::zeroed::<*mut vk::MemoryRequirements2<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetDeviceBufferMemoryRequirements"
			))
		));
	}
}

#[test]
fn get_device_buffer_memory_requirements_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::DeviceBufferMemoryRequirements<'_>,
		arg_2: *mut vk::MemoryRequirements2<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::DeviceBufferMemoryRequirements<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::MemoryRequirements2<'_>,
				)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetDeviceBufferMemoryRequirements = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetDeviceBufferMemoryRequirements,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkGetDeviceBufferMemoryRequirements", erased);
		let resolutions = Fixture::query_count();
		vk::get_device_buffer_memory_requirements(
			&fixture.device,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::DeviceBufferMemoryRequirements<'_>,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *mut vk::MemoryRequirements2<'_>,
		)
		.unwrap();
		vk::Device::get_device_buffer_memory_requirements(
			&fixture.device,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::DeviceBufferMemoryRequirements<'_>,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *mut vk::MemoryRequirements2<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_device_buffer_memory_requirements_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::DeviceBufferMemoryRequirements<'_>,
		*mut vk::MemoryRequirements2<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::get_device_buffer_memory_requirements_khr;
	let _: Signature = vk::Device::get_device_buffer_memory_requirements_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_device_buffer_memory_requirements_khr(
				&fixture.device,
				std::mem::zeroed::<*const vk::DeviceBufferMemoryRequirements<'_>>(),
				std::mem::zeroed::<*mut vk::MemoryRequirements2<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetDeviceBufferMemoryRequirementsKHR"
			))
		));
		assert!(matches!(
			fixture.device.get_device_buffer_memory_requirements_khr(
				std::mem::zeroed::<*const vk::DeviceBufferMemoryRequirements<'_>>(),
				std::mem::zeroed::<*mut vk::MemoryRequirements2<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetDeviceBufferMemoryRequirementsKHR"
			))
		));
	}
}

#[test]
fn get_device_buffer_memory_requirements_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::DeviceBufferMemoryRequirements<'_>,
		arg_2: *mut vk::MemoryRequirements2<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::DeviceBufferMemoryRequirements<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::MemoryRequirements2<'_>,
				)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetDeviceBufferMemoryRequirementsKHR = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetDeviceBufferMemoryRequirementsKHR,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkGetDeviceBufferMemoryRequirementsKHR", erased);
		let resolutions = Fixture::query_count();
		vk::get_device_buffer_memory_requirements_khr(
			&fixture.device,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::DeviceBufferMemoryRequirements<'_>,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *mut vk::MemoryRequirements2<'_>,
		)
		.unwrap();
		vk::Device::get_device_buffer_memory_requirements_khr(
			&fixture.device,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::DeviceBufferMemoryRequirements<'_>,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *mut vk::MemoryRequirements2<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_device_image_memory_requirements_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::DeviceImageMemoryRequirements<'_>,
		*mut vk::MemoryRequirements2<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::get_device_image_memory_requirements;
	let _: Signature = vk::Device::get_device_image_memory_requirements;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_device_image_memory_requirements(
				&fixture.device,
				std::mem::zeroed::<*const vk::DeviceImageMemoryRequirements<'_>>(),
				std::mem::zeroed::<*mut vk::MemoryRequirements2<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetDeviceImageMemoryRequirements"
			))
		));
		assert!(matches!(
			fixture.device.get_device_image_memory_requirements(
				std::mem::zeroed::<*const vk::DeviceImageMemoryRequirements<'_>>(),
				std::mem::zeroed::<*mut vk::MemoryRequirements2<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetDeviceImageMemoryRequirements"
			))
		));
	}
}

#[test]
fn get_device_image_memory_requirements_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::DeviceImageMemoryRequirements<'_>,
		arg_2: *mut vk::MemoryRequirements2<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::DeviceImageMemoryRequirements<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::MemoryRequirements2<'_>,
				)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetDeviceImageMemoryRequirements = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetDeviceImageMemoryRequirements,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkGetDeviceImageMemoryRequirements", erased);
		let resolutions = Fixture::query_count();
		vk::get_device_image_memory_requirements(
			&fixture.device,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::DeviceImageMemoryRequirements<'_>,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *mut vk::MemoryRequirements2<'_>,
		)
		.unwrap();
		vk::Device::get_device_image_memory_requirements(
			&fixture.device,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::DeviceImageMemoryRequirements<'_>,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *mut vk::MemoryRequirements2<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_device_image_memory_requirements_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::DeviceImageMemoryRequirements<'_>,
		*mut vk::MemoryRequirements2<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::get_device_image_memory_requirements_khr;
	let _: Signature = vk::Device::get_device_image_memory_requirements_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_device_image_memory_requirements_khr(
				&fixture.device,
				std::mem::zeroed::<*const vk::DeviceImageMemoryRequirements<'_>>(),
				std::mem::zeroed::<*mut vk::MemoryRequirements2<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetDeviceImageMemoryRequirementsKHR"
			))
		));
		assert!(matches!(
			fixture.device.get_device_image_memory_requirements_khr(
				std::mem::zeroed::<*const vk::DeviceImageMemoryRequirements<'_>>(),
				std::mem::zeroed::<*mut vk::MemoryRequirements2<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetDeviceImageMemoryRequirementsKHR"
			))
		));
	}
}

#[test]
fn get_device_image_memory_requirements_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::DeviceImageMemoryRequirements<'_>,
		arg_2: *mut vk::MemoryRequirements2<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::DeviceImageMemoryRequirements<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::MemoryRequirements2<'_>,
				)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetDeviceImageMemoryRequirementsKHR = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetDeviceImageMemoryRequirementsKHR,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkGetDeviceImageMemoryRequirementsKHR", erased);
		let resolutions = Fixture::query_count();
		vk::get_device_image_memory_requirements_khr(
			&fixture.device,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::DeviceImageMemoryRequirements<'_>,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *mut vk::MemoryRequirements2<'_>,
		)
		.unwrap();
		vk::Device::get_device_image_memory_requirements_khr(
			&fixture.device,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::DeviceImageMemoryRequirements<'_>,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *mut vk::MemoryRequirements2<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_device_image_sparse_memory_requirements_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::DeviceImageMemoryRequirements<'_>,
		*mut u32,
		*mut vk::SparseImageMemoryRequirements2<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::get_device_image_sparse_memory_requirements;
	let _: Signature = vk::Device::get_device_image_sparse_memory_requirements;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_device_image_sparse_memory_requirements(
				&fixture.device,
				std::mem::zeroed::<*const vk::DeviceImageMemoryRequirements<'_>>(),
				std::mem::zeroed::<*mut u32>(),
				std::mem::zeroed::<*mut vk::SparseImageMemoryRequirements2<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetDeviceImageSparseMemoryRequirements"
			))
		));
		assert!(matches!(
			fixture.device.get_device_image_sparse_memory_requirements(
				std::mem::zeroed::<*const vk::DeviceImageMemoryRequirements<'_>>(),
				std::mem::zeroed::<*mut u32>(),
				std::mem::zeroed::<*mut vk::SparseImageMemoryRequirements2<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetDeviceImageSparseMemoryRequirements"
			))
		));
	}
}

#[test]
fn get_device_image_sparse_memory_requirements_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::DeviceImageMemoryRequirements<'_>,
		arg_2: *mut u32,
		arg_3: *mut vk::SparseImageMemoryRequirements2<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::DeviceImageMemoryRequirements<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut u32,
				) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::SparseImageMemoryRequirements2<'_>,
				)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetDeviceImageSparseMemoryRequirements = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetDeviceImageSparseMemoryRequirements,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkGetDeviceImageSparseMemoryRequirements", erased);
		let resolutions = Fixture::query_count();
		vk::get_device_image_sparse_memory_requirements(
			&fixture.device,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::DeviceImageMemoryRequirements<'_>,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut u32,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
				as *mut vk::SparseImageMemoryRequirements2<'_>,
		)
		.unwrap();
		vk::Device::get_device_image_sparse_memory_requirements(
			&fixture.device,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::DeviceImageMemoryRequirements<'_>,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut u32,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
				as *mut vk::SparseImageMemoryRequirements2<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_device_image_sparse_memory_requirements_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::DeviceImageMemoryRequirements<'_>,
		*mut u32,
		*mut vk::SparseImageMemoryRequirements2<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::get_device_image_sparse_memory_requirements_khr;
	let _: Signature = vk::Device::get_device_image_sparse_memory_requirements_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_device_image_sparse_memory_requirements_khr(
				&fixture.device,
				std::mem::zeroed::<*const vk::DeviceImageMemoryRequirements<'_>>(),
				std::mem::zeroed::<*mut u32>(),
				std::mem::zeroed::<*mut vk::SparseImageMemoryRequirements2<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetDeviceImageSparseMemoryRequirementsKHR"
			))
		));
		assert!(matches!(
			fixture
				.device
				.get_device_image_sparse_memory_requirements_khr(
					std::mem::zeroed::<*const vk::DeviceImageMemoryRequirements<'_>>(),
					std::mem::zeroed::<*mut u32>(),
					std::mem::zeroed::<*mut vk::SparseImageMemoryRequirements2<'_>>()
				),
			Err(CallError::MissingCommand(
				"vkGetDeviceImageSparseMemoryRequirementsKHR"
			))
		));
	}
}

#[test]
fn get_device_image_sparse_memory_requirements_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::DeviceImageMemoryRequirements<'_>,
		arg_2: *mut u32,
		arg_3: *mut vk::SparseImageMemoryRequirements2<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::DeviceImageMemoryRequirements<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut u32,
				) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::SparseImageMemoryRequirements2<'_>,
				)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetDeviceImageSparseMemoryRequirementsKHR = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetDeviceImageSparseMemoryRequirementsKHR,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkGetDeviceImageSparseMemoryRequirementsKHR", erased);
		let resolutions = Fixture::query_count();
		vk::get_device_image_sparse_memory_requirements_khr(
			&fixture.device,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::DeviceImageMemoryRequirements<'_>,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut u32,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
				as *mut vk::SparseImageMemoryRequirements2<'_>,
		)
		.unwrap();
		vk::Device::get_device_image_sparse_memory_requirements_khr(
			&fixture.device,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::DeviceImageMemoryRequirements<'_>,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut u32,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
				as *mut vk::SparseImageMemoryRequirements2<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn create_sampler_ycbcr_conversion_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		&vk::SamplerYcbcrConversionCreateInfo<'_>,
		Option<&vk::AllocationCallbacks>,
	) -> Result<vk::SamplerYcbcrConversion, CallError>;
	let _: Signature = vk::create_sampler_ycbcr_conversion;
	let _: Signature = vk::Device::create_sampler_ycbcr_conversion;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::create_sampler_ycbcr_conversion(
				&fixture.device,
				&std::mem::zeroed::<vk::SamplerYcbcrConversionCreateInfo<'_>>(),
				None
			),
			Err(CallError::MissingCommand("vkCreateSamplerYcbcrConversion"))
		));
		assert!(matches!(
			fixture.device.create_sampler_ycbcr_conversion(
				&std::mem::zeroed::<vk::SamplerYcbcrConversionCreateInfo<'_>>(),
				None
			),
			Err(CallError::MissingCommand("vkCreateSamplerYcbcrConversion"))
		));
	}
}

#[test]
fn create_sampler_ycbcr_conversion_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		&vk::SamplerYcbcrConversionCreateInfo<'_>,
		Option<&vk::AllocationCallbacks>,
	) -> Result<vk::SamplerYcbcrConversion, CallError>;
	let _: Signature = vk::create_sampler_ycbcr_conversion_khr;
	let _: Signature = vk::Device::create_sampler_ycbcr_conversion_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::create_sampler_ycbcr_conversion_khr(
				&fixture.device,
				&std::mem::zeroed::<vk::SamplerYcbcrConversionCreateInfo<'_>>(),
				None
			),
			Err(CallError::MissingCommand(
				"vkCreateSamplerYcbcrConversionKHR"
			))
		));
		assert!(matches!(
			fixture.device.create_sampler_ycbcr_conversion_khr(
				&std::mem::zeroed::<vk::SamplerYcbcrConversionCreateInfo<'_>>(),
				None
			),
			Err(CallError::MissingCommand(
				"vkCreateSamplerYcbcrConversionKHR"
			))
		));
	}
}

#[test]
fn destroy_sampler_ycbcr_conversion_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::SamplerYcbcrConversion,
		Option<&vk::AllocationCallbacks>,
	) -> Result<(), CallError>;
	let _: Signature = vk::destroy_sampler_ycbcr_conversion;
	let _: Signature = vk::Device::destroy_sampler_ycbcr_conversion;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::destroy_sampler_ycbcr_conversion(&fixture.device, Default::default(), None),
			Err(CallError::MissingCommand("vkDestroySamplerYcbcrConversion"))
		));
		assert!(matches!(
			fixture
				.device
				.destroy_sampler_ycbcr_conversion(Default::default(), None),
			Err(CallError::MissingCommand("vkDestroySamplerYcbcrConversion"))
		));
	}
}

#[test]
fn destroy_sampler_ycbcr_conversion_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::SamplerYcbcrConversion,
		Option<&vk::AllocationCallbacks>,
	) -> Result<(), CallError>;
	let _: Signature = vk::destroy_sampler_ycbcr_conversion_khr;
	let _: Signature = vk::Device::destroy_sampler_ycbcr_conversion_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::destroy_sampler_ycbcr_conversion_khr(&fixture.device, Default::default(), None),
			Err(CallError::MissingCommand(
				"vkDestroySamplerYcbcrConversionKHR"
			))
		));
		assert!(matches!(
			fixture
				.device
				.destroy_sampler_ycbcr_conversion_khr(Default::default(), None),
			Err(CallError::MissingCommand(
				"vkDestroySamplerYcbcrConversionKHR"
			))
		));
	}
}

#[test]
fn get_device_queue2_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, &vk::DeviceQueueInfo2<'_>, &mut vk::Queue) -> Result<(), CallError>;
	let _: Signature = vk::get_device_queue2;
	let _: Signature = vk::Device::get_device_queue2;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_device_queue2(
				&fixture.device,
				&std::mem::zeroed::<vk::DeviceQueueInfo2<'_>>(),
				&mut std::mem::zeroed::<vk::Queue>()
			),
			Err(CallError::MissingCommand("vkGetDeviceQueue2"))
		));
		assert!(matches!(
			fixture.device.get_device_queue2(
				&std::mem::zeroed::<vk::DeviceQueueInfo2<'_>>(),
				&mut std::mem::zeroed::<vk::Queue>()
			),
			Err(CallError::MissingCommand("vkGetDeviceQueue2"))
		));
	}
}

#[test]
fn create_validation_cache_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::ValidationCacheCreateInfoEXT<'_>,
		*const vk::AllocationCallbacks,
		*mut vk::ValidationCacheEXT,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::create_validation_cache_ext;
	let _: Signature = vk::Device::create_validation_cache_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::create_validation_cache_ext(
				&fixture.device,
				std::mem::zeroed::<*const vk::ValidationCacheCreateInfoEXT<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::ValidationCacheEXT>()
			),
			Err(CallError::MissingCommand("vkCreateValidationCacheEXT"))
		));
		assert!(matches!(
			fixture.device.create_validation_cache_ext(
				std::mem::zeroed::<*const vk::ValidationCacheCreateInfoEXT<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::ValidationCacheEXT>()
			),
			Err(CallError::MissingCommand("vkCreateValidationCacheEXT"))
		));
	}
}

#[test]
fn create_validation_cache_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::ValidationCacheCreateInfoEXT<'_>,
		arg_2: *const vk::AllocationCallbacks,
		arg_3: *mut vk::ValidationCacheEXT,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::ValidationCacheCreateInfoEXT<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
				) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::ValidationCacheEXT,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCreateValidationCacheEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCreateValidationCacheEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCreateValidationCacheEXT", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::create_validation_cache_ext(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::ValidationCacheCreateInfoEXT<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::ValidationCacheEXT
				),
				expected
			);
			assert_eq!(
				vk::Device::create_validation_cache_ext(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::ValidationCacheCreateInfoEXT<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::ValidationCacheEXT
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn destroy_validation_cache_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::ValidationCacheEXT,
		*const vk::AllocationCallbacks,
	) -> Result<(), CallError>;
	let _: Signature = vk::destroy_validation_cache_ext;
	let _: Signature = vk::Device::destroy_validation_cache_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::destroy_validation_cache_ext(
				&fixture.device,
				std::mem::zeroed::<vk::ValidationCacheEXT>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>()
			),
			Err(CallError::MissingCommand("vkDestroyValidationCacheEXT"))
		));
		assert!(matches!(
			fixture.device.destroy_validation_cache_ext(
				std::mem::zeroed::<vk::ValidationCacheEXT>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>()
			),
			Err(CallError::MissingCommand("vkDestroyValidationCacheEXT"))
		));
	}
}

#[test]
fn destroy_validation_cache_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::ValidationCacheEXT,
		arg_2: *const vk::AllocationCallbacks,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::ValidationCacheEXT::from_raw(305398016_u64 as _)
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *const vk::AllocationCallbacks,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkDestroyValidationCacheEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkDestroyValidationCacheEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkDestroyValidationCacheEXT", erased);
		let resolutions = Fixture::query_count();
		vk::destroy_validation_cache_ext(
			&fixture.device,
			vk::ValidationCacheEXT::from_raw(305398016_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::AllocationCallbacks,
		)
		.unwrap();
		vk::Device::destroy_validation_cache_ext(
			&fixture.device,
			vk::ValidationCacheEXT::from_raw(305398016_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::AllocationCallbacks,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_validation_cache_data_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::ValidationCacheEXT,
		*mut usize,
		*mut std::ffi::c_void,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_validation_cache_data_ext;
	let _: Signature = vk::Device::get_validation_cache_data_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_validation_cache_data_ext(
				&fixture.device,
				std::mem::zeroed::<vk::ValidationCacheEXT>(),
				std::mem::zeroed::<*mut usize>(),
				std::mem::zeroed::<*mut std::ffi::c_void>()
			),
			Err(CallError::MissingCommand("vkGetValidationCacheDataEXT"))
		));
		assert!(matches!(
			fixture.device.get_validation_cache_data_ext(
				std::mem::zeroed::<vk::ValidationCacheEXT>(),
				std::mem::zeroed::<*mut usize>(),
				std::mem::zeroed::<*mut std::ffi::c_void>()
			),
			Err(CallError::MissingCommand("vkGetValidationCacheDataEXT"))
		));
	}
}

#[test]
fn get_validation_cache_data_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::ValidationCacheEXT,
		arg_2: *mut usize,
		arg_3: *mut std::ffi::c_void,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::ValidationCacheEXT::from_raw(305398016_u64 as _)
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut usize,
					) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528),
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetValidationCacheDataEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkGetValidationCacheDataEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkGetValidationCacheDataEXT", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_validation_cache_data_ext(
					&fixture.device,
					vk::ValidationCacheEXT::from_raw(305398016_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut usize,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
				),
				expected
			);
			assert_eq!(
				vk::Device::get_validation_cache_data_ext(
					&fixture.device,
					vk::ValidationCacheEXT::from_raw(305398016_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut usize,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn merge_validation_caches_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::ValidationCacheEXT,
		u32,
		*const vk::ValidationCacheEXT,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::merge_validation_caches_ext;
	let _: Signature = vk::Device::merge_validation_caches_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::merge_validation_caches_ext(
				&fixture.device,
				std::mem::zeroed::<vk::ValidationCacheEXT>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::ValidationCacheEXT>()
			),
			Err(CallError::MissingCommand("vkMergeValidationCachesEXT"))
		));
		assert!(matches!(
			fixture.device.merge_validation_caches_ext(
				std::mem::zeroed::<vk::ValidationCacheEXT>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::ValidationCacheEXT>()
			),
			Err(CallError::MissingCommand("vkMergeValidationCachesEXT"))
		));
	}
}

#[test]
fn merge_validation_caches_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::ValidationCacheEXT,
		arg_2: u32,
		arg_3: *const vk::ValidationCacheEXT,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::ValidationCacheEXT::from_raw(305398016_u64 as _)
					&& arg_2 == Default::default()
					&& std::ptr::eq(
						arg_3,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
							as *const vk::ValidationCacheEXT,
					)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkMergeValidationCachesEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkMergeValidationCachesEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkMergeValidationCachesEXT", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::merge_validation_caches_ext(
					&fixture.device,
					vk::ValidationCacheEXT::from_raw(305398016_u64 as _),
					Default::default(),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *const vk::ValidationCacheEXT
				),
				expected
			);
			assert_eq!(
				vk::Device::merge_validation_caches_ext(
					&fixture.device,
					vk::ValidationCacheEXT::from_raw(305398016_u64 as _),
					Default::default(),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *const vk::ValidationCacheEXT
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_descriptor_set_layout_support_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		&vk::DescriptorSetLayoutCreateInfo<'_>,
		&mut vk::DescriptorSetLayoutSupport<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::get_descriptor_set_layout_support;
	let _: Signature = vk::Device::get_descriptor_set_layout_support;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_descriptor_set_layout_support(
				&fixture.device,
				&std::mem::zeroed::<vk::DescriptorSetLayoutCreateInfo<'_>>(),
				&mut std::mem::zeroed::<vk::DescriptorSetLayoutSupport<'_>>()
			),
			Err(CallError::MissingCommand("vkGetDescriptorSetLayoutSupport"))
		));
		assert!(matches!(
			fixture.device.get_descriptor_set_layout_support(
				&std::mem::zeroed::<vk::DescriptorSetLayoutCreateInfo<'_>>(),
				&mut std::mem::zeroed::<vk::DescriptorSetLayoutSupport<'_>>()
			),
			Err(CallError::MissingCommand("vkGetDescriptorSetLayoutSupport"))
		));
	}
}

#[test]
fn get_descriptor_set_layout_support_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		&vk::DescriptorSetLayoutCreateInfo<'_>,
		&mut vk::DescriptorSetLayoutSupport<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::get_descriptor_set_layout_support_khr;
	let _: Signature = vk::Device::get_descriptor_set_layout_support_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_descriptor_set_layout_support_khr(
				&fixture.device,
				&std::mem::zeroed::<vk::DescriptorSetLayoutCreateInfo<'_>>(),
				&mut std::mem::zeroed::<vk::DescriptorSetLayoutSupport<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetDescriptorSetLayoutSupportKHR"
			))
		));
		assert!(matches!(
			fixture.device.get_descriptor_set_layout_support_khr(
				&std::mem::zeroed::<vk::DescriptorSetLayoutCreateInfo<'_>>(),
				&mut std::mem::zeroed::<vk::DescriptorSetLayoutSupport<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetDescriptorSetLayoutSupportKHR"
			))
		));
	}
}

#[test]
fn get_shader_info_amd_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::Pipeline,
		vk::ShaderStageFlagBits,
		vk::ShaderInfoTypeAMD,
		*mut usize,
		*mut std::ffi::c_void,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_shader_info_amd;
	let _: Signature = vk::Device::get_shader_info_amd;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_shader_info_amd(
				&fixture.device,
				std::mem::zeroed::<vk::Pipeline>(),
				std::mem::zeroed::<vk::ShaderStageFlagBits>(),
				std::mem::zeroed::<vk::ShaderInfoTypeAMD>(),
				std::mem::zeroed::<*mut usize>(),
				std::mem::zeroed::<*mut std::ffi::c_void>()
			),
			Err(CallError::MissingCommand("vkGetShaderInfoAMD"))
		));
		assert!(matches!(
			fixture.device.get_shader_info_amd(
				std::mem::zeroed::<vk::Pipeline>(),
				std::mem::zeroed::<vk::ShaderStageFlagBits>(),
				std::mem::zeroed::<vk::ShaderInfoTypeAMD>(),
				std::mem::zeroed::<*mut usize>(),
				std::mem::zeroed::<*mut std::ffi::c_void>()
			),
			Err(CallError::MissingCommand("vkGetShaderInfoAMD"))
		));
	}
}

#[test]
fn get_shader_info_amd_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::Pipeline,
		arg_2: vk::ShaderStageFlagBits,
		arg_3: vk::ShaderInfoTypeAMD,
		arg_4: *mut usize,
		arg_5: *mut std::ffi::c_void,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::Pipeline::from_raw(305398016_u64 as _)
					&& arg_2 == vk::ShaderStageFlagBits::from_raw(305398272_u64 as _)
					&& arg_3 == vk::ShaderInfoTypeAMD::from_raw(305398528_u64 as _)
					&& std::ptr::eq(
						arg_4,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784) as *mut usize,
					) && std::ptr::eq(
					arg_5,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305399040),
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetShaderInfoAMD = Some(mock);
		let erased = std::mem::transmute::<vk::PFN_vkGetShaderInfoAMD, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkGetShaderInfoAMD", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_shader_info_amd(
					&fixture.device,
					vk::Pipeline::from_raw(305398016_u64 as _),
					vk::ShaderStageFlagBits::from_raw(305398272_u64 as _),
					vk::ShaderInfoTypeAMD::from_raw(305398528_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784) as *mut usize,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305399040)
				),
				expected
			);
			assert_eq!(
				vk::Device::get_shader_info_amd(
					&fixture.device,
					vk::Pipeline::from_raw(305398016_u64 as _),
					vk::ShaderStageFlagBits::from_raw(305398272_u64 as _),
					vk::ShaderInfoTypeAMD::from_raw(305398528_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784) as *mut usize,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305399040)
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn set_local_dimming_amd_signature_and_missing_command() {
	type Signature = unsafe fn(&vk::Device, vk::SwapchainKHR, vk::Bool32) -> Result<(), CallError>;
	let _: Signature = vk::set_local_dimming_amd;
	let _: Signature = vk::Device::set_local_dimming_amd;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::set_local_dimming_amd(
				&fixture.device,
				std::mem::zeroed::<vk::SwapchainKHR>(),
				std::mem::zeroed::<vk::Bool32>()
			),
			Err(CallError::MissingCommand("vkSetLocalDimmingAMD"))
		));
		assert!(matches!(
			fixture.device.set_local_dimming_amd(
				std::mem::zeroed::<vk::SwapchainKHR>(),
				std::mem::zeroed::<vk::Bool32>()
			),
			Err(CallError::MissingCommand("vkSetLocalDimmingAMD"))
		));
	}
}

#[test]
fn set_local_dimming_amd_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::SwapchainKHR,
		arg_2: vk::Bool32,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::SwapchainKHR::from_raw(305398016_u64 as _)
					&& arg_2 == 305398272_u64 as vk::Bool32),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkSetLocalDimmingAMD = Some(mock);
		let erased = std::mem::transmute::<vk::PFN_vkSetLocalDimmingAMD, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkSetLocalDimmingAMD", erased);
		let resolutions = Fixture::query_count();
		vk::set_local_dimming_amd(
			&fixture.device,
			vk::SwapchainKHR::from_raw(305398016_u64 as _),
			305398272_u64 as vk::Bool32,
		)
		.unwrap();
		vk::Device::set_local_dimming_amd(
			&fixture.device,
			vk::SwapchainKHR::from_raw(305398016_u64 as _),
			305398272_u64 as vk::Bool32,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_physical_device_calibrateable_time_domains_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		vk::PhysicalDevice,
		*mut u32,
		*mut vk::TimeDomainKHR,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_physical_device_calibrateable_time_domains_khr;
	let _: Signature = vk::Instance::get_physical_device_calibrateable_time_domains_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_physical_device_calibrateable_time_domains_khr(
				&fixture.instance,
				std::mem::zeroed::<vk::PhysicalDevice>(),
				std::mem::zeroed::<*mut u32>(),
				std::mem::zeroed::<*mut vk::TimeDomainKHR>()
			),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceCalibrateableTimeDomainsKHR"
			))
		));
		assert!(matches!(
			fixture
				.instance
				.get_physical_device_calibrateable_time_domains_khr(
					std::mem::zeroed::<vk::PhysicalDevice>(),
					std::mem::zeroed::<*mut u32>(),
					std::mem::zeroed::<*mut vk::TimeDomainKHR>()
				),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceCalibrateableTimeDomainsKHR"
			))
		));
	}
}

#[test]
fn get_physical_device_calibrateable_time_domains_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::PhysicalDevice,
		arg_1: *mut u32,
		arg_2: *mut vk::TimeDomainKHR,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::PhysicalDevice::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016) as *mut u32,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut vk::TimeDomainKHR,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture =
			Fixture::new_with_command(c"vkGetPhysicalDeviceCalibrateableTimeDomainsKHR", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_physical_device_calibrateable_time_domains_khr(
					&fixture.instance,
					vk::PhysicalDevice::from_raw(305397760_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016) as *mut u32,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut vk::TimeDomainKHR
				),
				expected
			);
			assert_eq!(
				vk::Instance::get_physical_device_calibrateable_time_domains_khr(
					&fixture.instance,
					vk::PhysicalDevice::from_raw(305397760_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016) as *mut u32,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut vk::TimeDomainKHR
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_physical_device_calibrateable_time_domains_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		vk::PhysicalDevice,
		*mut u32,
		*mut vk::TimeDomainKHR,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_physical_device_calibrateable_time_domains_ext;
	let _: Signature = vk::Instance::get_physical_device_calibrateable_time_domains_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_physical_device_calibrateable_time_domains_ext(
				&fixture.instance,
				std::mem::zeroed::<vk::PhysicalDevice>(),
				std::mem::zeroed::<*mut u32>(),
				std::mem::zeroed::<*mut vk::TimeDomainKHR>()
			),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceCalibrateableTimeDomainsEXT"
			))
		));
		assert!(matches!(
			fixture
				.instance
				.get_physical_device_calibrateable_time_domains_ext(
					std::mem::zeroed::<vk::PhysicalDevice>(),
					std::mem::zeroed::<*mut u32>(),
					std::mem::zeroed::<*mut vk::TimeDomainKHR>()
				),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceCalibrateableTimeDomainsEXT"
			))
		));
	}
}

#[test]
fn get_physical_device_calibrateable_time_domains_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::PhysicalDevice,
		arg_1: *mut u32,
		arg_2: *mut vk::TimeDomainKHR,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::PhysicalDevice::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016) as *mut u32,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut vk::TimeDomainKHR,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture =
			Fixture::new_with_command(c"vkGetPhysicalDeviceCalibrateableTimeDomainsEXT", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_physical_device_calibrateable_time_domains_ext(
					&fixture.instance,
					vk::PhysicalDevice::from_raw(305397760_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016) as *mut u32,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut vk::TimeDomainKHR
				),
				expected
			);
			assert_eq!(
				vk::Instance::get_physical_device_calibrateable_time_domains_ext(
					&fixture.instance,
					vk::PhysicalDevice::from_raw(305397760_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016) as *mut u32,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut vk::TimeDomainKHR
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_calibrated_timestamps_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		u32,
		*const vk::CalibratedTimestampInfoKHR<'_>,
		*mut u64,
		*mut u64,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_calibrated_timestamps_khr;
	let _: Signature = vk::Device::get_calibrated_timestamps_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_calibrated_timestamps_khr(
				&fixture.device,
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::CalibratedTimestampInfoKHR<'_>>(),
				std::mem::zeroed::<*mut u64>(),
				std::mem::zeroed::<*mut u64>()
			),
			Err(CallError::MissingCommand("vkGetCalibratedTimestampsKHR"))
		));
		assert!(matches!(
			fixture.device.get_calibrated_timestamps_khr(
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::CalibratedTimestampInfoKHR<'_>>(),
				std::mem::zeroed::<*mut u64>(),
				std::mem::zeroed::<*mut u64>()
			),
			Err(CallError::MissingCommand("vkGetCalibratedTimestampsKHR"))
		));
	}
}

#[test]
fn get_calibrated_timestamps_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: u32,
		arg_2: *const vk::CalibratedTimestampInfoKHR<'_>,
		arg_3: *mut u64,
		arg_4: *mut u64,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == Default::default()
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *const vk::CalibratedTimestampInfoKHR<'_>,
					) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut u64,
				) && std::ptr::eq(
					arg_4,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784) as *mut u64,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetCalibratedTimestampsKHR = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkGetCalibratedTimestampsKHR, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkGetCalibratedTimestampsKHR", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_calibrated_timestamps_khr(
					&fixture.device,
					Default::default(),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::CalibratedTimestampInfoKHR<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut u64,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784) as *mut u64
				),
				expected
			);
			assert_eq!(
				vk::Device::get_calibrated_timestamps_khr(
					&fixture.device,
					Default::default(),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::CalibratedTimestampInfoKHR<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut u64,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784) as *mut u64
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_calibrated_timestamps_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		u32,
		*const vk::CalibratedTimestampInfoKHR<'_>,
		*mut u64,
		*mut u64,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_calibrated_timestamps_ext;
	let _: Signature = vk::Device::get_calibrated_timestamps_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_calibrated_timestamps_ext(
				&fixture.device,
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::CalibratedTimestampInfoKHR<'_>>(),
				std::mem::zeroed::<*mut u64>(),
				std::mem::zeroed::<*mut u64>()
			),
			Err(CallError::MissingCommand("vkGetCalibratedTimestampsEXT"))
		));
		assert!(matches!(
			fixture.device.get_calibrated_timestamps_ext(
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::CalibratedTimestampInfoKHR<'_>>(),
				std::mem::zeroed::<*mut u64>(),
				std::mem::zeroed::<*mut u64>()
			),
			Err(CallError::MissingCommand("vkGetCalibratedTimestampsEXT"))
		));
	}
}

#[test]
fn get_calibrated_timestamps_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: u32,
		arg_2: *const vk::CalibratedTimestampInfoKHR<'_>,
		arg_3: *mut u64,
		arg_4: *mut u64,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == Default::default()
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *const vk::CalibratedTimestampInfoKHR<'_>,
					) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut u64,
				) && std::ptr::eq(
					arg_4,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784) as *mut u64,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetCalibratedTimestampsEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkGetCalibratedTimestampsEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkGetCalibratedTimestampsEXT", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_calibrated_timestamps_ext(
					&fixture.device,
					Default::default(),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::CalibratedTimestampInfoKHR<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut u64,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784) as *mut u64
				),
				expected
			);
			assert_eq!(
				vk::Device::get_calibrated_timestamps_ext(
					&fixture.device,
					Default::default(),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::CalibratedTimestampInfoKHR<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut u64,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784) as *mut u64
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn set_debug_utils_object_name_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::DebugUtilsObjectNameInfoEXT<'_>,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::set_debug_utils_object_name_ext;
	let _: Signature = vk::Device::set_debug_utils_object_name_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::set_debug_utils_object_name_ext(
				&fixture.device,
				std::mem::zeroed::<*const vk::DebugUtilsObjectNameInfoEXT<'_>>()
			),
			Err(CallError::MissingCommand("vkSetDebugUtilsObjectNameEXT"))
		));
		assert!(matches!(
			fixture
				.device
				.set_debug_utils_object_name_ext(std::mem::zeroed::<
					*const vk::DebugUtilsObjectNameInfoEXT<'_>,
				>()),
			Err(CallError::MissingCommand("vkSetDebugUtilsObjectNameEXT"))
		));
	}
}

#[test]
fn set_debug_utils_object_name_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::DebugUtilsObjectNameInfoEXT<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::DebugUtilsObjectNameInfoEXT<'_>,
					)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkSetDebugUtilsObjectNameEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkSetDebugUtilsObjectNameEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkSetDebugUtilsObjectNameEXT", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::set_debug_utils_object_name_ext(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::DebugUtilsObjectNameInfoEXT<'_>
				),
				expected
			);
			assert_eq!(
				vk::Device::set_debug_utils_object_name_ext(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::DebugUtilsObjectNameInfoEXT<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn set_debug_utils_object_tag_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::DebugUtilsObjectTagInfoEXT<'_>,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::set_debug_utils_object_tag_ext;
	let _: Signature = vk::Device::set_debug_utils_object_tag_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::set_debug_utils_object_tag_ext(
				&fixture.device,
				std::mem::zeroed::<*const vk::DebugUtilsObjectTagInfoEXT<'_>>()
			),
			Err(CallError::MissingCommand("vkSetDebugUtilsObjectTagEXT"))
		));
		assert!(matches!(
			fixture
				.device
				.set_debug_utils_object_tag_ext(std::mem::zeroed::<
					*const vk::DebugUtilsObjectTagInfoEXT<'_>,
				>()),
			Err(CallError::MissingCommand("vkSetDebugUtilsObjectTagEXT"))
		));
	}
}

#[test]
fn set_debug_utils_object_tag_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::DebugUtilsObjectTagInfoEXT<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::DebugUtilsObjectTagInfoEXT<'_>,
					)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkSetDebugUtilsObjectTagEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkSetDebugUtilsObjectTagEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkSetDebugUtilsObjectTagEXT", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::set_debug_utils_object_tag_ext(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::DebugUtilsObjectTagInfoEXT<'_>
				),
				expected
			);
			assert_eq!(
				vk::Device::set_debug_utils_object_tag_ext(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::DebugUtilsObjectTagInfoEXT<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn queue_begin_debug_utils_label_ext_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, vk::Queue, *const vk::DebugUtilsLabelEXT<'_>) -> Result<(), CallError>;
	let _: Signature = vk::queue_begin_debug_utils_label_ext;
	let _: Signature = vk::Device::queue_begin_debug_utils_label_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::queue_begin_debug_utils_label_ext(
				&fixture.device,
				std::mem::zeroed::<vk::Queue>(),
				std::mem::zeroed::<*const vk::DebugUtilsLabelEXT<'_>>()
			),
			Err(CallError::MissingCommand("vkQueueBeginDebugUtilsLabelEXT"))
		));
		assert!(matches!(
			fixture.device.queue_begin_debug_utils_label_ext(
				std::mem::zeroed::<vk::Queue>(),
				std::mem::zeroed::<*const vk::DebugUtilsLabelEXT<'_>>()
			),
			Err(CallError::MissingCommand("vkQueueBeginDebugUtilsLabelEXT"))
		));
	}
}

#[test]
fn queue_begin_debug_utils_label_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::Queue, arg_1: *const vk::DebugUtilsLabelEXT<'_>) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::Queue::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::DebugUtilsLabelEXT<'_>,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkQueueBeginDebugUtilsLabelEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkQueueBeginDebugUtilsLabelEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkQueueBeginDebugUtilsLabelEXT", erased);
		let resolutions = Fixture::query_count();
		vk::queue_begin_debug_utils_label_ext(
			&fixture.device,
			vk::Queue::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::DebugUtilsLabelEXT<'_>,
		)
		.unwrap();
		vk::Device::queue_begin_debug_utils_label_ext(
			&fixture.device,
			vk::Queue::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::DebugUtilsLabelEXT<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn queue_end_debug_utils_label_ext_signature_and_missing_command() {
	type Signature = unsafe fn(&vk::Device, vk::Queue) -> Result<(), CallError>;
	let _: Signature = vk::queue_end_debug_utils_label_ext;
	let _: Signature = vk::Device::queue_end_debug_utils_label_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::queue_end_debug_utils_label_ext(&fixture.device, std::mem::zeroed::<vk::Queue>()),
			Err(CallError::MissingCommand("vkQueueEndDebugUtilsLabelEXT"))
		));
		assert!(matches!(
			fixture
				.device
				.queue_end_debug_utils_label_ext(std::mem::zeroed::<vk::Queue>()),
			Err(CallError::MissingCommand("vkQueueEndDebugUtilsLabelEXT"))
		));
	}
}

#[test]
fn queue_end_debug_utils_label_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::Queue) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(MATCHED.get() && (arg_0 == vk::Queue::from_raw(305397760_u64 as _)));
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkQueueEndDebugUtilsLabelEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkQueueEndDebugUtilsLabelEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkQueueEndDebugUtilsLabelEXT", erased);
		let resolutions = Fixture::query_count();
		vk::queue_end_debug_utils_label_ext(&fixture.device, vk::Queue::from_raw(305397760_u64 as _))
			.unwrap();
		vk::Device::queue_end_debug_utils_label_ext(
			&fixture.device,
			vk::Queue::from_raw(305397760_u64 as _),
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn queue_insert_debug_utils_label_ext_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, vk::Queue, *const vk::DebugUtilsLabelEXT<'_>) -> Result<(), CallError>;
	let _: Signature = vk::queue_insert_debug_utils_label_ext;
	let _: Signature = vk::Device::queue_insert_debug_utils_label_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::queue_insert_debug_utils_label_ext(
				&fixture.device,
				std::mem::zeroed::<vk::Queue>(),
				std::mem::zeroed::<*const vk::DebugUtilsLabelEXT<'_>>()
			),
			Err(CallError::MissingCommand("vkQueueInsertDebugUtilsLabelEXT"))
		));
		assert!(matches!(
			fixture.device.queue_insert_debug_utils_label_ext(
				std::mem::zeroed::<vk::Queue>(),
				std::mem::zeroed::<*const vk::DebugUtilsLabelEXT<'_>>()
			),
			Err(CallError::MissingCommand("vkQueueInsertDebugUtilsLabelEXT"))
		));
	}
}

#[test]
fn queue_insert_debug_utils_label_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::Queue, arg_1: *const vk::DebugUtilsLabelEXT<'_>) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::Queue::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::DebugUtilsLabelEXT<'_>,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkQueueInsertDebugUtilsLabelEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkQueueInsertDebugUtilsLabelEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkQueueInsertDebugUtilsLabelEXT", erased);
		let resolutions = Fixture::query_count();
		vk::queue_insert_debug_utils_label_ext(
			&fixture.device,
			vk::Queue::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::DebugUtilsLabelEXT<'_>,
		)
		.unwrap();
		vk::Device::queue_insert_debug_utils_label_ext(
			&fixture.device,
			vk::Queue::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::DebugUtilsLabelEXT<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_begin_debug_utils_label_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		*const vk::DebugUtilsLabelEXT<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_begin_debug_utils_label_ext;
	let _: Signature = vk::Device::cmd_begin_debug_utils_label_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_begin_debug_utils_label_ext(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::DebugUtilsLabelEXT<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdBeginDebugUtilsLabelEXT"))
		));
		assert!(matches!(
			fixture.device.cmd_begin_debug_utils_label_ext(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::DebugUtilsLabelEXT<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdBeginDebugUtilsLabelEXT"))
		));
	}
}

#[test]
fn cmd_begin_debug_utils_label_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: *const vk::DebugUtilsLabelEXT<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::DebugUtilsLabelEXT<'_>,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdBeginDebugUtilsLabelEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdBeginDebugUtilsLabelEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdBeginDebugUtilsLabelEXT", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_begin_debug_utils_label_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::DebugUtilsLabelEXT<'_>,
		)
		.unwrap();
		vk::Device::cmd_begin_debug_utils_label_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::DebugUtilsLabelEXT<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_end_debug_utils_label_ext_signature_and_missing_command() {
	type Signature = unsafe fn(&vk::Device, vk::CommandBuffer) -> Result<(), CallError>;
	let _: Signature = vk::cmd_end_debug_utils_label_ext;
	let _: Signature = vk::Device::cmd_end_debug_utils_label_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_end_debug_utils_label_ext(&fixture.device, std::mem::zeroed::<vk::CommandBuffer>()),
			Err(CallError::MissingCommand("vkCmdEndDebugUtilsLabelEXT"))
		));
		assert!(matches!(
			fixture
				.device
				.cmd_end_debug_utils_label_ext(std::mem::zeroed::<vk::CommandBuffer>()),
			Err(CallError::MissingCommand("vkCmdEndDebugUtilsLabelEXT"))
		));
	}
}

#[test]
fn cmd_end_debug_utils_label_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::CommandBuffer) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(MATCHED.get() && (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)));
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdEndDebugUtilsLabelEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdEndDebugUtilsLabelEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdEndDebugUtilsLabelEXT", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_end_debug_utils_label_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
		)
		.unwrap();
		vk::Device::cmd_end_debug_utils_label_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_insert_debug_utils_label_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		*const vk::DebugUtilsLabelEXT<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_insert_debug_utils_label_ext;
	let _: Signature = vk::Device::cmd_insert_debug_utils_label_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_insert_debug_utils_label_ext(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::DebugUtilsLabelEXT<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdInsertDebugUtilsLabelEXT"))
		));
		assert!(matches!(
			fixture.device.cmd_insert_debug_utils_label_ext(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::DebugUtilsLabelEXT<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdInsertDebugUtilsLabelEXT"))
		));
	}
}

#[test]
fn cmd_insert_debug_utils_label_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: *const vk::DebugUtilsLabelEXT<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::DebugUtilsLabelEXT<'_>,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdInsertDebugUtilsLabelEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdInsertDebugUtilsLabelEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdInsertDebugUtilsLabelEXT", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_insert_debug_utils_label_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::DebugUtilsLabelEXT<'_>,
		)
		.unwrap();
		vk::Device::cmd_insert_debug_utils_label_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::DebugUtilsLabelEXT<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn create_debug_utils_messenger_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		*const vk::DebugUtilsMessengerCreateInfoEXT<'_>,
		*const vk::AllocationCallbacks,
		*mut vk::DebugUtilsMessengerEXT,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::create_debug_utils_messenger_ext;
	let _: Signature = vk::Instance::create_debug_utils_messenger_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::create_debug_utils_messenger_ext(
				&fixture.instance,
				std::mem::zeroed::<*const vk::DebugUtilsMessengerCreateInfoEXT<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::DebugUtilsMessengerEXT>()
			),
			Err(CallError::MissingCommand("vkCreateDebugUtilsMessengerEXT"))
		));
		assert!(matches!(
			fixture.instance.create_debug_utils_messenger_ext(
				std::mem::zeroed::<*const vk::DebugUtilsMessengerCreateInfoEXT<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::DebugUtilsMessengerEXT>()
			),
			Err(CallError::MissingCommand("vkCreateDebugUtilsMessengerEXT"))
		));
	}
}

#[test]
fn create_debug_utils_messenger_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::InstanceHandle,
		arg_1: *const vk::DebugUtilsMessengerCreateInfoEXT<'_>,
		arg_2: *const vk::AllocationCallbacks,
		arg_3: *mut vk::DebugUtilsMessengerEXT,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::InstanceHandle::from_raw(0x1000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::DebugUtilsMessengerCreateInfoEXT<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
				) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::DebugUtilsMessengerEXT,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCreateDebugUtilsMessengerEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCreateDebugUtilsMessengerEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCreateDebugUtilsMessengerEXT", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::create_debug_utils_messenger_ext(
					&fixture.instance,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::DebugUtilsMessengerCreateInfoEXT<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::DebugUtilsMessengerEXT
				),
				expected
			);
			assert_eq!(
				vk::Instance::create_debug_utils_messenger_ext(
					&fixture.instance,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::DebugUtilsMessengerCreateInfoEXT<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::DebugUtilsMessengerEXT
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn destroy_debug_utils_messenger_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		vk::DebugUtilsMessengerEXT,
		*const vk::AllocationCallbacks,
	) -> Result<(), CallError>;
	let _: Signature = vk::destroy_debug_utils_messenger_ext;
	let _: Signature = vk::Instance::destroy_debug_utils_messenger_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::destroy_debug_utils_messenger_ext(
				&fixture.instance,
				std::mem::zeroed::<vk::DebugUtilsMessengerEXT>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>()
			),
			Err(CallError::MissingCommand("vkDestroyDebugUtilsMessengerEXT"))
		));
		assert!(matches!(
			fixture.instance.destroy_debug_utils_messenger_ext(
				std::mem::zeroed::<vk::DebugUtilsMessengerEXT>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>()
			),
			Err(CallError::MissingCommand("vkDestroyDebugUtilsMessengerEXT"))
		));
	}
}

#[test]
fn destroy_debug_utils_messenger_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::InstanceHandle,
		arg_1: vk::DebugUtilsMessengerEXT,
		arg_2: *const vk::AllocationCallbacks,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::InstanceHandle::from_raw(0x1000)
					&& arg_1 == vk::DebugUtilsMessengerEXT::from_raw(305398016_u64 as _)
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *const vk::AllocationCallbacks,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkDestroyDebugUtilsMessengerEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkDestroyDebugUtilsMessengerEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkDestroyDebugUtilsMessengerEXT", erased);
		let resolutions = Fixture::query_count();
		vk::destroy_debug_utils_messenger_ext(
			&fixture.instance,
			vk::DebugUtilsMessengerEXT::from_raw(305398016_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::AllocationCallbacks,
		)
		.unwrap();
		vk::Instance::destroy_debug_utils_messenger_ext(
			&fixture.instance,
			vk::DebugUtilsMessengerEXT::from_raw(305398016_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::AllocationCallbacks,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn submit_debug_utils_message_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		vk::DebugUtilsMessageSeverityFlagBitsEXT,
		vk::DebugUtilsMessageTypeFlagsEXT,
		*const vk::DebugUtilsMessengerCallbackDataEXT<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::submit_debug_utils_message_ext;
	let _: Signature = vk::Instance::submit_debug_utils_message_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::submit_debug_utils_message_ext(
				&fixture.instance,
				std::mem::zeroed::<vk::DebugUtilsMessageSeverityFlagBitsEXT>(),
				std::mem::zeroed::<vk::DebugUtilsMessageTypeFlagsEXT>(),
				std::mem::zeroed::<*const vk::DebugUtilsMessengerCallbackDataEXT<'_>>()
			),
			Err(CallError::MissingCommand("vkSubmitDebugUtilsMessageEXT"))
		));
		assert!(matches!(
			fixture.instance.submit_debug_utils_message_ext(
				std::mem::zeroed::<vk::DebugUtilsMessageSeverityFlagBitsEXT>(),
				std::mem::zeroed::<vk::DebugUtilsMessageTypeFlagsEXT>(),
				std::mem::zeroed::<*const vk::DebugUtilsMessengerCallbackDataEXT<'_>>()
			),
			Err(CallError::MissingCommand("vkSubmitDebugUtilsMessageEXT"))
		));
	}
}

#[test]
fn submit_debug_utils_message_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::InstanceHandle,
		arg_1: vk::DebugUtilsMessageSeverityFlagBitsEXT,
		arg_2: vk::DebugUtilsMessageTypeFlagsEXT,
		arg_3: *const vk::DebugUtilsMessengerCallbackDataEXT<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::InstanceHandle::from_raw(0x1000)
					&& arg_1 == vk::DebugUtilsMessageSeverityFlagBitsEXT::from_raw(305398016_u64 as _)
					&& arg_2 == vk::DebugUtilsMessageTypeFlagsEXT::from_raw(305398272_u64 as _)
					&& std::ptr::eq(
						arg_3,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
							as *const vk::DebugUtilsMessengerCallbackDataEXT<'_>,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkSubmitDebugUtilsMessageEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkSubmitDebugUtilsMessageEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkSubmitDebugUtilsMessageEXT", erased);
		let resolutions = Fixture::query_count();
		vk::submit_debug_utils_message_ext(
			&fixture.instance,
			vk::DebugUtilsMessageSeverityFlagBitsEXT::from_raw(305398016_u64 as _),
			vk::DebugUtilsMessageTypeFlagsEXT::from_raw(305398272_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
				as *const vk::DebugUtilsMessengerCallbackDataEXT<'_>,
		)
		.unwrap();
		vk::Instance::submit_debug_utils_message_ext(
			&fixture.instance,
			vk::DebugUtilsMessageSeverityFlagBitsEXT::from_raw(305398016_u64 as _),
			vk::DebugUtilsMessageTypeFlagsEXT::from_raw(305398272_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
				as *const vk::DebugUtilsMessengerCallbackDataEXT<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_memory_host_pointer_properties_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::ExternalMemoryHandleTypeFlagBits,
		*const std::ffi::c_void,
		*mut vk::MemoryHostPointerPropertiesEXT<'_>,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_memory_host_pointer_properties_ext;
	let _: Signature = vk::Device::get_memory_host_pointer_properties_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_memory_host_pointer_properties_ext(
				&fixture.device,
				std::mem::zeroed::<vk::ExternalMemoryHandleTypeFlagBits>(),
				std::mem::zeroed::<*const std::ffi::c_void>(),
				std::mem::zeroed::<*mut vk::MemoryHostPointerPropertiesEXT<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetMemoryHostPointerPropertiesEXT"
			))
		));
		assert!(matches!(
			fixture.device.get_memory_host_pointer_properties_ext(
				std::mem::zeroed::<vk::ExternalMemoryHandleTypeFlagBits>(),
				std::mem::zeroed::<*const std::ffi::c_void>(),
				std::mem::zeroed::<*mut vk::MemoryHostPointerPropertiesEXT<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetMemoryHostPointerPropertiesEXT"
			))
		));
	}
}

#[test]
fn get_memory_host_pointer_properties_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::ExternalMemoryHandleTypeFlagBits,
		arg_2: *const std::ffi::c_void,
		arg_3: *mut vk::MemoryHostPointerPropertiesEXT<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::ExternalMemoryHandleTypeFlagBits::from_raw(305398016_u64 as _)
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *const std::ffi::c_void,
					) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::MemoryHostPointerPropertiesEXT<'_>,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetMemoryHostPointerPropertiesEXT = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetMemoryHostPointerPropertiesEXT,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkGetMemoryHostPointerPropertiesEXT", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_memory_host_pointer_properties_ext(
					&fixture.device,
					vk::ExternalMemoryHandleTypeFlagBits::from_raw(305398016_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const std::ffi::c_void,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::MemoryHostPointerPropertiesEXT<'_>
				),
				expected
			);
			assert_eq!(
				vk::Device::get_memory_host_pointer_properties_ext(
					&fixture.device,
					vk::ExternalMemoryHandleTypeFlagBits::from_raw(305398016_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const std::ffi::c_void,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::MemoryHostPointerPropertiesEXT<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_write_buffer_marker_amd_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		vk::PipelineStageFlagBits,
		vk::Buffer,
		vk::DeviceSize,
		u32,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_write_buffer_marker_amd;
	let _: Signature = vk::Device::cmd_write_buffer_marker_amd;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_write_buffer_marker_amd(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::PipelineStageFlagBits>(),
				std::mem::zeroed::<vk::Buffer>(),
				std::mem::zeroed::<vk::DeviceSize>(),
				std::mem::zeroed::<u32>()
			),
			Err(CallError::MissingCommand("vkCmdWriteBufferMarkerAMD"))
		));
		assert!(matches!(
			fixture.device.cmd_write_buffer_marker_amd(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::PipelineStageFlagBits>(),
				std::mem::zeroed::<vk::Buffer>(),
				std::mem::zeroed::<vk::DeviceSize>(),
				std::mem::zeroed::<u32>()
			),
			Err(CallError::MissingCommand("vkCmdWriteBufferMarkerAMD"))
		));
	}
}

#[test]
fn cmd_write_buffer_marker_amd_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: vk::PipelineStageFlagBits,
		arg_2: vk::Buffer,
		arg_3: vk::DeviceSize,
		arg_4: u32,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == vk::PipelineStageFlagBits::from_raw(305398016_u64 as _)
					&& arg_2 == vk::Buffer::from_raw(305398272_u64 as _)
					&& arg_3 == 305398528_u64 as vk::DeviceSize
					&& arg_4 == Default::default()),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdWriteBufferMarkerAMD = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdWriteBufferMarkerAMD, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdWriteBufferMarkerAMD", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_write_buffer_marker_amd(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::PipelineStageFlagBits::from_raw(305398016_u64 as _),
			vk::Buffer::from_raw(305398272_u64 as _),
			305398528_u64 as vk::DeviceSize,
			Default::default(),
		)
		.unwrap();
		vk::Device::cmd_write_buffer_marker_amd(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::PipelineStageFlagBits::from_raw(305398016_u64 as _),
			vk::Buffer::from_raw(305398272_u64 as _),
			305398528_u64 as vk::DeviceSize,
			Default::default(),
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn create_render_pass2_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		&vk::RenderPassCreateInfo2<'_>,
		Option<&vk::AllocationCallbacks>,
	) -> Result<vk::RenderPass, CallError>;
	let _: Signature = vk::create_render_pass2;
	let _: Signature = vk::Device::create_render_pass2;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::create_render_pass2(
				&fixture.device,
				&std::mem::zeroed::<vk::RenderPassCreateInfo2<'_>>(),
				None
			),
			Err(CallError::MissingCommand("vkCreateRenderPass2"))
		));
		assert!(matches!(
			fixture
				.device
				.create_render_pass2(&std::mem::zeroed::<vk::RenderPassCreateInfo2<'_>>(), None),
			Err(CallError::MissingCommand("vkCreateRenderPass2"))
		));
	}
}

#[test]
fn create_render_pass2_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		&vk::RenderPassCreateInfo2<'_>,
		Option<&vk::AllocationCallbacks>,
	) -> Result<vk::RenderPass, CallError>;
	let _: Signature = vk::create_render_pass2_khr;
	let _: Signature = vk::Device::create_render_pass2_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::create_render_pass2_khr(
				&fixture.device,
				&std::mem::zeroed::<vk::RenderPassCreateInfo2<'_>>(),
				None
			),
			Err(CallError::MissingCommand("vkCreateRenderPass2KHR"))
		));
		assert!(matches!(
			fixture
				.device
				.create_render_pass2_khr(&std::mem::zeroed::<vk::RenderPassCreateInfo2<'_>>(), None),
			Err(CallError::MissingCommand("vkCreateRenderPass2KHR"))
		));
	}
}

#[test]
fn cmd_begin_render_pass2_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		&vk::RenderPassBeginInfo<'_>,
		&vk::SubpassBeginInfo<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_begin_render_pass2;
	let _: Signature = vk::Device::cmd_begin_render_pass2;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_begin_render_pass2(
				&fixture.device,
				Default::default(),
				&std::mem::zeroed::<vk::RenderPassBeginInfo<'_>>(),
				&std::mem::zeroed::<vk::SubpassBeginInfo<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdBeginRenderPass2"))
		));
		assert!(matches!(
			fixture.device.cmd_begin_render_pass2(
				Default::default(),
				&std::mem::zeroed::<vk::RenderPassBeginInfo<'_>>(),
				&std::mem::zeroed::<vk::SubpassBeginInfo<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdBeginRenderPass2"))
		));
	}
}

#[test]
fn cmd_begin_render_pass2_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		&vk::RenderPassBeginInfo<'_>,
		&vk::SubpassBeginInfo<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_begin_render_pass2_khr;
	let _: Signature = vk::Device::cmd_begin_render_pass2_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_begin_render_pass2_khr(
				&fixture.device,
				Default::default(),
				&std::mem::zeroed::<vk::RenderPassBeginInfo<'_>>(),
				&std::mem::zeroed::<vk::SubpassBeginInfo<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdBeginRenderPass2KHR"))
		));
		assert!(matches!(
			fixture.device.cmd_begin_render_pass2_khr(
				Default::default(),
				&std::mem::zeroed::<vk::RenderPassBeginInfo<'_>>(),
				&std::mem::zeroed::<vk::SubpassBeginInfo<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdBeginRenderPass2KHR"))
		));
	}
}

#[test]
fn cmd_next_subpass2_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		&vk::SubpassBeginInfo<'_>,
		&vk::SubpassEndInfo<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_next_subpass2;
	let _: Signature = vk::Device::cmd_next_subpass2;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_next_subpass2(
				&fixture.device,
				Default::default(),
				&std::mem::zeroed::<vk::SubpassBeginInfo<'_>>(),
				&std::mem::zeroed::<vk::SubpassEndInfo<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdNextSubpass2"))
		));
		assert!(matches!(
			fixture.device.cmd_next_subpass2(
				Default::default(),
				&std::mem::zeroed::<vk::SubpassBeginInfo<'_>>(),
				&std::mem::zeroed::<vk::SubpassEndInfo<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdNextSubpass2"))
		));
	}
}

#[test]
fn cmd_next_subpass2_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		&vk::SubpassBeginInfo<'_>,
		&vk::SubpassEndInfo<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_next_subpass2_khr;
	let _: Signature = vk::Device::cmd_next_subpass2_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_next_subpass2_khr(
				&fixture.device,
				Default::default(),
				&std::mem::zeroed::<vk::SubpassBeginInfo<'_>>(),
				&std::mem::zeroed::<vk::SubpassEndInfo<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdNextSubpass2KHR"))
		));
		assert!(matches!(
			fixture.device.cmd_next_subpass2_khr(
				Default::default(),
				&std::mem::zeroed::<vk::SubpassBeginInfo<'_>>(),
				&std::mem::zeroed::<vk::SubpassEndInfo<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdNextSubpass2KHR"))
		));
	}
}

#[test]
fn cmd_end_render_pass2_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, vk::CommandBuffer, &vk::SubpassEndInfo<'_>) -> Result<(), CallError>;
	let _: Signature = vk::cmd_end_render_pass2;
	let _: Signature = vk::Device::cmd_end_render_pass2;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_end_render_pass2(
				&fixture.device,
				Default::default(),
				&std::mem::zeroed::<vk::SubpassEndInfo<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdEndRenderPass2"))
		));
		assert!(matches!(
			fixture.device.cmd_end_render_pass2(
				Default::default(),
				&std::mem::zeroed::<vk::SubpassEndInfo<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdEndRenderPass2"))
		));
	}
}

#[test]
fn cmd_end_render_pass2_khr_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, vk::CommandBuffer, &vk::SubpassEndInfo<'_>) -> Result<(), CallError>;
	let _: Signature = vk::cmd_end_render_pass2_khr;
	let _: Signature = vk::Device::cmd_end_render_pass2_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_end_render_pass2_khr(
				&fixture.device,
				Default::default(),
				&std::mem::zeroed::<vk::SubpassEndInfo<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdEndRenderPass2KHR"))
		));
		assert!(matches!(
			fixture.device.cmd_end_render_pass2_khr(
				Default::default(),
				&std::mem::zeroed::<vk::SubpassEndInfo<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdEndRenderPass2KHR"))
		));
	}
}

#[test]
fn get_semaphore_counter_value_signature_and_missing_command() {
	type Signature = unsafe fn(&vk::Device, vk::Semaphore, &mut u64) -> Result<(), CallError>;
	let _: Signature = vk::get_semaphore_counter_value;
	let _: Signature = vk::Device::get_semaphore_counter_value;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_semaphore_counter_value(
				&fixture.device,
				Default::default(),
				&mut std::mem::zeroed::<u64>()
			),
			Err(CallError::MissingCommand("vkGetSemaphoreCounterValue"))
		));
		assert!(matches!(
			fixture
				.device
				.get_semaphore_counter_value(Default::default(), &mut std::mem::zeroed::<u64>()),
			Err(CallError::MissingCommand("vkGetSemaphoreCounterValue"))
		));
	}
}

#[test]
fn get_semaphore_counter_value_khr_signature_and_missing_command() {
	type Signature = unsafe fn(&vk::Device, vk::Semaphore, &mut u64) -> Result<(), CallError>;
	let _: Signature = vk::get_semaphore_counter_value_khr;
	let _: Signature = vk::Device::get_semaphore_counter_value_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_semaphore_counter_value_khr(
				&fixture.device,
				Default::default(),
				&mut std::mem::zeroed::<u64>()
			),
			Err(CallError::MissingCommand("vkGetSemaphoreCounterValueKHR"))
		));
		assert!(matches!(
			fixture
				.device
				.get_semaphore_counter_value_khr(Default::default(), &mut std::mem::zeroed::<u64>()),
			Err(CallError::MissingCommand("vkGetSemaphoreCounterValueKHR"))
		));
	}
}

#[test]
fn wait_semaphores_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, &vk::SemaphoreWaitInfo<'_>, u64) -> Result<vk::Result, CallError>;
	let _: Signature = vk::wait_semaphores;
	let _: Signature = vk::Device::wait_semaphores;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::wait_semaphores(
				&fixture.device,
				&std::mem::zeroed::<vk::SemaphoreWaitInfo<'_>>(),
				Default::default()
			),
			Err(CallError::MissingCommand("vkWaitSemaphores"))
		));
		assert!(matches!(
			fixture.device.wait_semaphores(
				&std::mem::zeroed::<vk::SemaphoreWaitInfo<'_>>(),
				Default::default()
			),
			Err(CallError::MissingCommand("vkWaitSemaphores"))
		));
	}
}

#[test]
fn wait_semaphores_khr_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, &vk::SemaphoreWaitInfo<'_>, u64) -> Result<vk::Result, CallError>;
	let _: Signature = vk::wait_semaphores_khr;
	let _: Signature = vk::Device::wait_semaphores_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::wait_semaphores_khr(
				&fixture.device,
				&std::mem::zeroed::<vk::SemaphoreWaitInfo<'_>>(),
				Default::default()
			),
			Err(CallError::MissingCommand("vkWaitSemaphoresKHR"))
		));
		assert!(matches!(
			fixture.device.wait_semaphores_khr(
				&std::mem::zeroed::<vk::SemaphoreWaitInfo<'_>>(),
				Default::default()
			),
			Err(CallError::MissingCommand("vkWaitSemaphoresKHR"))
		));
	}
}

#[test]
fn signal_semaphore_signature_and_missing_command() {
	type Signature = unsafe fn(&vk::Device, &vk::SemaphoreSignalInfo<'_>) -> Result<(), CallError>;
	let _: Signature = vk::signal_semaphore;
	let _: Signature = vk::Device::signal_semaphore;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::signal_semaphore(
				&fixture.device,
				&std::mem::zeroed::<vk::SemaphoreSignalInfo<'_>>()
			),
			Err(CallError::MissingCommand("vkSignalSemaphore"))
		));
		assert!(matches!(
			fixture
				.device
				.signal_semaphore(&std::mem::zeroed::<vk::SemaphoreSignalInfo<'_>>()),
			Err(CallError::MissingCommand("vkSignalSemaphore"))
		));
	}
}

#[test]
fn signal_semaphore_khr_signature_and_missing_command() {
	type Signature = unsafe fn(&vk::Device, &vk::SemaphoreSignalInfo<'_>) -> Result<(), CallError>;
	let _: Signature = vk::signal_semaphore_khr;
	let _: Signature = vk::Device::signal_semaphore_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::signal_semaphore_khr(
				&fixture.device,
				&std::mem::zeroed::<vk::SemaphoreSignalInfo<'_>>()
			),
			Err(CallError::MissingCommand("vkSignalSemaphoreKHR"))
		));
		assert!(matches!(
			fixture
				.device
				.signal_semaphore_khr(&std::mem::zeroed::<vk::SemaphoreSignalInfo<'_>>()),
			Err(CallError::MissingCommand("vkSignalSemaphoreKHR"))
		));
	}
}

#[cfg(feature = "platform-android")]
#[test]
fn get_android_hardware_buffer_properties_android_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::AHardwareBuffer,
		*mut vk::AndroidHardwareBufferPropertiesANDROID<'_>,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_android_hardware_buffer_properties_android;
	let _: Signature = vk::Device::get_android_hardware_buffer_properties_android;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_android_hardware_buffer_properties_android(
				&fixture.device,
				std::mem::zeroed::<*const vk::AHardwareBuffer>(),
				std::mem::zeroed::<*mut vk::AndroidHardwareBufferPropertiesANDROID<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetAndroidHardwareBufferPropertiesANDROID"
			))
		));
		assert!(matches!(
			fixture
				.device
				.get_android_hardware_buffer_properties_android(
					std::mem::zeroed::<*const vk::AHardwareBuffer>(),
					std::mem::zeroed::<*mut vk::AndroidHardwareBufferPropertiesANDROID<'_>>()
				),
			Err(CallError::MissingCommand(
				"vkGetAndroidHardwareBufferPropertiesANDROID"
			))
		));
	}
}

#[cfg(feature = "platform-android")]
#[test]
fn get_android_hardware_buffer_properties_android_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::AHardwareBuffer,
		arg_2: *mut vk::AndroidHardwareBufferPropertiesANDROID<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::AHardwareBuffer,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::AndroidHardwareBufferPropertiesANDROID<'_>,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetAndroidHardwareBufferPropertiesANDROID = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetAndroidHardwareBufferPropertiesANDROID,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkGetAndroidHardwareBufferPropertiesANDROID", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_android_hardware_buffer_properties_android(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::AHardwareBuffer,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::AndroidHardwareBufferPropertiesANDROID<'_>
				),
				expected
			);
			assert_eq!(
				vk::Device::get_android_hardware_buffer_properties_android(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::AHardwareBuffer,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::AndroidHardwareBufferPropertiesANDROID<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[cfg(feature = "platform-android")]
#[test]
fn get_memory_android_hardware_buffer_android_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::MemoryGetAndroidHardwareBufferInfoANDROID<'_>,
		*mut *mut vk::AHardwareBuffer,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_memory_android_hardware_buffer_android;
	let _: Signature = vk::Device::get_memory_android_hardware_buffer_android;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_memory_android_hardware_buffer_android(
				&fixture.device,
				std::mem::zeroed::<*const vk::MemoryGetAndroidHardwareBufferInfoANDROID<'_>>(),
				std::mem::zeroed::<*mut *mut vk::AHardwareBuffer>()
			),
			Err(CallError::MissingCommand(
				"vkGetMemoryAndroidHardwareBufferANDROID"
			))
		));
		assert!(matches!(
			fixture.device.get_memory_android_hardware_buffer_android(
				std::mem::zeroed::<*const vk::MemoryGetAndroidHardwareBufferInfoANDROID<'_>>(),
				std::mem::zeroed::<*mut *mut vk::AHardwareBuffer>()
			),
			Err(CallError::MissingCommand(
				"vkGetMemoryAndroidHardwareBufferANDROID"
			))
		));
	}
}

#[cfg(feature = "platform-android")]
#[test]
fn get_memory_android_hardware_buffer_android_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::MemoryGetAndroidHardwareBufferInfoANDROID<'_>,
		arg_2: *mut *mut vk::AHardwareBuffer,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::MemoryGetAndroidHardwareBufferInfoANDROID<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut *mut vk::AHardwareBuffer,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetMemoryAndroidHardwareBufferANDROID = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetMemoryAndroidHardwareBufferANDROID,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkGetMemoryAndroidHardwareBufferANDROID", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_memory_android_hardware_buffer_android(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::MemoryGetAndroidHardwareBufferInfoANDROID<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut *mut vk::AHardwareBuffer
				),
				expected
			);
			assert_eq!(
				vk::Device::get_memory_android_hardware_buffer_android(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::MemoryGetAndroidHardwareBufferInfoANDROID<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut *mut vk::AHardwareBuffer
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_draw_indirect_count_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		vk::Buffer,
		vk::DeviceSize,
		vk::Buffer,
		vk::DeviceSize,
		u32,
		u32,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_draw_indirect_count;
	let _: Signature = vk::Device::cmd_draw_indirect_count;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_draw_indirect_count(
				&fixture.device,
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default()
			),
			Err(CallError::MissingCommand("vkCmdDrawIndirectCount"))
		));
		assert!(matches!(
			fixture.device.cmd_draw_indirect_count(
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default()
			),
			Err(CallError::MissingCommand("vkCmdDrawIndirectCount"))
		));
	}
}

#[test]
fn cmd_draw_indirect_count_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		vk::Buffer,
		vk::DeviceSize,
		vk::Buffer,
		vk::DeviceSize,
		u32,
		u32,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_draw_indirect_count_khr;
	let _: Signature = vk::Device::cmd_draw_indirect_count_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_draw_indirect_count_khr(
				&fixture.device,
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default()
			),
			Err(CallError::MissingCommand("vkCmdDrawIndirectCountKHR"))
		));
		assert!(matches!(
			fixture.device.cmd_draw_indirect_count_khr(
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default()
			),
			Err(CallError::MissingCommand("vkCmdDrawIndirectCountKHR"))
		));
	}
}

#[test]
fn cmd_draw_indirect_count_amd_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		vk::Buffer,
		vk::DeviceSize,
		vk::Buffer,
		vk::DeviceSize,
		u32,
		u32,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_draw_indirect_count_amd;
	let _: Signature = vk::Device::cmd_draw_indirect_count_amd;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_draw_indirect_count_amd(
				&fixture.device,
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default()
			),
			Err(CallError::MissingCommand("vkCmdDrawIndirectCountAMD"))
		));
		assert!(matches!(
			fixture.device.cmd_draw_indirect_count_amd(
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default()
			),
			Err(CallError::MissingCommand("vkCmdDrawIndirectCountAMD"))
		));
	}
}

#[test]
fn cmd_draw_indexed_indirect_count_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		vk::Buffer,
		vk::DeviceSize,
		vk::Buffer,
		vk::DeviceSize,
		u32,
		u32,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_draw_indexed_indirect_count;
	let _: Signature = vk::Device::cmd_draw_indexed_indirect_count;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_draw_indexed_indirect_count(
				&fixture.device,
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default()
			),
			Err(CallError::MissingCommand("vkCmdDrawIndexedIndirectCount"))
		));
		assert!(matches!(
			fixture.device.cmd_draw_indexed_indirect_count(
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default()
			),
			Err(CallError::MissingCommand("vkCmdDrawIndexedIndirectCount"))
		));
	}
}

#[test]
fn cmd_draw_indexed_indirect_count_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		vk::Buffer,
		vk::DeviceSize,
		vk::Buffer,
		vk::DeviceSize,
		u32,
		u32,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_draw_indexed_indirect_count_khr;
	let _: Signature = vk::Device::cmd_draw_indexed_indirect_count_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_draw_indexed_indirect_count_khr(
				&fixture.device,
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default()
			),
			Err(CallError::MissingCommand(
				"vkCmdDrawIndexedIndirectCountKHR"
			))
		));
		assert!(matches!(
			fixture.device.cmd_draw_indexed_indirect_count_khr(
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default()
			),
			Err(CallError::MissingCommand(
				"vkCmdDrawIndexedIndirectCountKHR"
			))
		));
	}
}

#[test]
fn cmd_draw_indexed_indirect_count_amd_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		vk::Buffer,
		vk::DeviceSize,
		vk::Buffer,
		vk::DeviceSize,
		u32,
		u32,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_draw_indexed_indirect_count_amd;
	let _: Signature = vk::Device::cmd_draw_indexed_indirect_count_amd;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_draw_indexed_indirect_count_amd(
				&fixture.device,
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default()
			),
			Err(CallError::MissingCommand(
				"vkCmdDrawIndexedIndirectCountAMD"
			))
		));
		assert!(matches!(
			fixture.device.cmd_draw_indexed_indirect_count_amd(
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default()
			),
			Err(CallError::MissingCommand(
				"vkCmdDrawIndexedIndirectCountAMD"
			))
		));
	}
}

#[test]
fn cmd_set_checkpoint_nv_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, vk::CommandBuffer, *const std::ffi::c_void) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_checkpoint_nv;
	let _: Signature = vk::Device::cmd_set_checkpoint_nv;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_checkpoint_nv(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const std::ffi::c_void>()
			),
			Err(CallError::MissingCommand("vkCmdSetCheckpointNV"))
		));
		assert!(matches!(
			fixture.device.cmd_set_checkpoint_nv(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const std::ffi::c_void>()
			),
			Err(CallError::MissingCommand("vkCmdSetCheckpointNV"))
		));
	}
}

#[test]
fn cmd_set_checkpoint_nv_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::CommandBuffer, arg_1: *const std::ffi::c_void) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const std::ffi::c_void,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdSetCheckpointNV = Some(mock);
		let erased = std::mem::transmute::<vk::PFN_vkCmdSetCheckpointNV, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdSetCheckpointNV", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_set_checkpoint_nv(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016) as *const std::ffi::c_void,
		)
		.unwrap();
		vk::Device::cmd_set_checkpoint_nv(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016) as *const std::ffi::c_void,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_queue_checkpoint_data_nv_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::Queue,
		*mut u32,
		*mut vk::CheckpointDataNV<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::get_queue_checkpoint_data_nv;
	let _: Signature = vk::Device::get_queue_checkpoint_data_nv;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_queue_checkpoint_data_nv(
				&fixture.device,
				std::mem::zeroed::<vk::Queue>(),
				std::mem::zeroed::<*mut u32>(),
				std::mem::zeroed::<*mut vk::CheckpointDataNV<'_>>()
			),
			Err(CallError::MissingCommand("vkGetQueueCheckpointDataNV"))
		));
		assert!(matches!(
			fixture.device.get_queue_checkpoint_data_nv(
				std::mem::zeroed::<vk::Queue>(),
				std::mem::zeroed::<*mut u32>(),
				std::mem::zeroed::<*mut vk::CheckpointDataNV<'_>>()
			),
			Err(CallError::MissingCommand("vkGetQueueCheckpointDataNV"))
		));
	}
}

#[test]
fn get_queue_checkpoint_data_nv_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::Queue,
		arg_1: *mut u32,
		arg_2: *mut vk::CheckpointDataNV<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::Queue::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016) as *mut u32,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::CheckpointDataNV<'_>,
				)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetQueueCheckpointDataNV = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkGetQueueCheckpointDataNV, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkGetQueueCheckpointDataNV", erased);
		let resolutions = Fixture::query_count();
		vk::get_queue_checkpoint_data_nv(
			&fixture.device,
			vk::Queue::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016) as *mut u32,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *mut vk::CheckpointDataNV<'_>,
		)
		.unwrap();
		vk::Device::get_queue_checkpoint_data_nv(
			&fixture.device,
			vk::Queue::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016) as *mut u32,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *mut vk::CheckpointDataNV<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_bind_transform_feedback_buffers_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		u32,
		u32,
		*const vk::Buffer,
		*const vk::DeviceSize,
		*const vk::DeviceSize,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_bind_transform_feedback_buffers_ext;
	let _: Signature = vk::Device::cmd_bind_transform_feedback_buffers_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_bind_transform_feedback_buffers_ext(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::Buffer>(),
				std::mem::zeroed::<*const vk::DeviceSize>(),
				std::mem::zeroed::<*const vk::DeviceSize>()
			),
			Err(CallError::MissingCommand(
				"vkCmdBindTransformFeedbackBuffersEXT"
			))
		));
		assert!(matches!(
			fixture.device.cmd_bind_transform_feedback_buffers_ext(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::Buffer>(),
				std::mem::zeroed::<*const vk::DeviceSize>(),
				std::mem::zeroed::<*const vk::DeviceSize>()
			),
			Err(CallError::MissingCommand(
				"vkCmdBindTransformFeedbackBuffersEXT"
			))
		));
	}
}

#[test]
fn cmd_bind_transform_feedback_buffers_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: u32,
		arg_2: u32,
		arg_3: *const vk::Buffer,
		arg_4: *const vk::DeviceSize,
		arg_5: *const vk::DeviceSize,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == Default::default()
					&& arg_2 == Default::default()
					&& std::ptr::eq(
						arg_3,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *const vk::Buffer,
					) && std::ptr::eq(
					arg_4,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784) as *const vk::DeviceSize,
				) && std::ptr::eq(
					arg_5,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305399040) as *const vk::DeviceSize,
				)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdBindTransformFeedbackBuffersEXT = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkCmdBindTransformFeedbackBuffersEXT,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdBindTransformFeedbackBuffersEXT", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_bind_transform_feedback_buffers_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *const vk::Buffer,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784) as *const vk::DeviceSize,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305399040) as *const vk::DeviceSize,
		)
		.unwrap();
		vk::Device::cmd_bind_transform_feedback_buffers_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *const vk::Buffer,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784) as *const vk::DeviceSize,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305399040) as *const vk::DeviceSize,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_begin_transform_feedback_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		u32,
		u32,
		*const vk::Buffer,
		*const vk::DeviceSize,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_begin_transform_feedback_ext;
	let _: Signature = vk::Device::cmd_begin_transform_feedback_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_begin_transform_feedback_ext(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::Buffer>(),
				std::mem::zeroed::<*const vk::DeviceSize>()
			),
			Err(CallError::MissingCommand("vkCmdBeginTransformFeedbackEXT"))
		));
		assert!(matches!(
			fixture.device.cmd_begin_transform_feedback_ext(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::Buffer>(),
				std::mem::zeroed::<*const vk::DeviceSize>()
			),
			Err(CallError::MissingCommand("vkCmdBeginTransformFeedbackEXT"))
		));
	}
}

#[test]
fn cmd_begin_transform_feedback_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: u32,
		arg_2: u32,
		arg_3: *const vk::Buffer,
		arg_4: *const vk::DeviceSize,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == Default::default()
					&& arg_2 == Default::default()
					&& std::ptr::eq(
						arg_3,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *const vk::Buffer,
					) && std::ptr::eq(
					arg_4,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784) as *const vk::DeviceSize,
				)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdBeginTransformFeedbackEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdBeginTransformFeedbackEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdBeginTransformFeedbackEXT", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_begin_transform_feedback_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *const vk::Buffer,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784) as *const vk::DeviceSize,
		)
		.unwrap();
		vk::Device::cmd_begin_transform_feedback_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *const vk::Buffer,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784) as *const vk::DeviceSize,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_end_transform_feedback_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		u32,
		u32,
		*const vk::Buffer,
		*const vk::DeviceSize,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_end_transform_feedback_ext;
	let _: Signature = vk::Device::cmd_end_transform_feedback_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_end_transform_feedback_ext(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::Buffer>(),
				std::mem::zeroed::<*const vk::DeviceSize>()
			),
			Err(CallError::MissingCommand("vkCmdEndTransformFeedbackEXT"))
		));
		assert!(matches!(
			fixture.device.cmd_end_transform_feedback_ext(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::Buffer>(),
				std::mem::zeroed::<*const vk::DeviceSize>()
			),
			Err(CallError::MissingCommand("vkCmdEndTransformFeedbackEXT"))
		));
	}
}

#[test]
fn cmd_end_transform_feedback_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: u32,
		arg_2: u32,
		arg_3: *const vk::Buffer,
		arg_4: *const vk::DeviceSize,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == Default::default()
					&& arg_2 == Default::default()
					&& std::ptr::eq(
						arg_3,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *const vk::Buffer,
					) && std::ptr::eq(
					arg_4,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784) as *const vk::DeviceSize,
				)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdEndTransformFeedbackEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdEndTransformFeedbackEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdEndTransformFeedbackEXT", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_end_transform_feedback_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *const vk::Buffer,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784) as *const vk::DeviceSize,
		)
		.unwrap();
		vk::Device::cmd_end_transform_feedback_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *const vk::Buffer,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784) as *const vk::DeviceSize,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_begin_query_indexed_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		vk::QueryPool,
		u32,
		vk::QueryControlFlags,
		u32,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_begin_query_indexed_ext;
	let _: Signature = vk::Device::cmd_begin_query_indexed_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_begin_query_indexed_ext(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::QueryPool>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<vk::QueryControlFlags>(),
				std::mem::zeroed::<u32>()
			),
			Err(CallError::MissingCommand("vkCmdBeginQueryIndexedEXT"))
		));
		assert!(matches!(
			fixture.device.cmd_begin_query_indexed_ext(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::QueryPool>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<vk::QueryControlFlags>(),
				std::mem::zeroed::<u32>()
			),
			Err(CallError::MissingCommand("vkCmdBeginQueryIndexedEXT"))
		));
	}
}

#[test]
fn cmd_begin_query_indexed_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: vk::QueryPool,
		arg_2: u32,
		arg_3: vk::QueryControlFlags,
		arg_4: u32,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == vk::QueryPool::from_raw(305398016_u64 as _)
					&& arg_2 == Default::default()
					&& arg_3 == vk::QueryControlFlags::from_raw(305398528_u64 as _)
					&& arg_4 == Default::default()),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdBeginQueryIndexedEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdBeginQueryIndexedEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdBeginQueryIndexedEXT", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_begin_query_indexed_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::QueryPool::from_raw(305398016_u64 as _),
			Default::default(),
			vk::QueryControlFlags::from_raw(305398528_u64 as _),
			Default::default(),
		)
		.unwrap();
		vk::Device::cmd_begin_query_indexed_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::QueryPool::from_raw(305398016_u64 as _),
			Default::default(),
			vk::QueryControlFlags::from_raw(305398528_u64 as _),
			Default::default(),
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_end_query_indexed_ext_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, vk::CommandBuffer, vk::QueryPool, u32, u32) -> Result<(), CallError>;
	let _: Signature = vk::cmd_end_query_indexed_ext;
	let _: Signature = vk::Device::cmd_end_query_indexed_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_end_query_indexed_ext(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::QueryPool>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>()
			),
			Err(CallError::MissingCommand("vkCmdEndQueryIndexedEXT"))
		));
		assert!(matches!(
			fixture.device.cmd_end_query_indexed_ext(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::QueryPool>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>()
			),
			Err(CallError::MissingCommand("vkCmdEndQueryIndexedEXT"))
		));
	}
}

#[test]
fn cmd_end_query_indexed_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: vk::QueryPool,
		arg_2: u32,
		arg_3: u32,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == vk::QueryPool::from_raw(305398016_u64 as _)
					&& arg_2 == Default::default()
					&& arg_3 == Default::default()),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdEndQueryIndexedEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdEndQueryIndexedEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdEndQueryIndexedEXT", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_end_query_indexed_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::QueryPool::from_raw(305398016_u64 as _),
			Default::default(),
			Default::default(),
		)
		.unwrap();
		vk::Device::cmd_end_query_indexed_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::QueryPool::from_raw(305398016_u64 as _),
			Default::default(),
			Default::default(),
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_draw_indirect_byte_count_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		u32,
		u32,
		vk::Buffer,
		vk::DeviceSize,
		u32,
		u32,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_draw_indirect_byte_count_ext;
	let _: Signature = vk::Device::cmd_draw_indirect_byte_count_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_draw_indirect_byte_count_ext(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<vk::Buffer>(),
				std::mem::zeroed::<vk::DeviceSize>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>()
			),
			Err(CallError::MissingCommand("vkCmdDrawIndirectByteCountEXT"))
		));
		assert!(matches!(
			fixture.device.cmd_draw_indirect_byte_count_ext(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<vk::Buffer>(),
				std::mem::zeroed::<vk::DeviceSize>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>()
			),
			Err(CallError::MissingCommand("vkCmdDrawIndirectByteCountEXT"))
		));
	}
}

#[test]
fn cmd_draw_indirect_byte_count_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: u32,
		arg_2: u32,
		arg_3: vk::Buffer,
		arg_4: vk::DeviceSize,
		arg_5: u32,
		arg_6: u32,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == Default::default()
					&& arg_2 == Default::default()
					&& arg_3 == vk::Buffer::from_raw(305398528_u64 as _)
					&& arg_4 == 305398784_u64 as vk::DeviceSize
					&& arg_5 == Default::default()
					&& arg_6 == Default::default()),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdDrawIndirectByteCountEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdDrawIndirectByteCountEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdDrawIndirectByteCountEXT", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_draw_indirect_byte_count_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
			Default::default(),
			vk::Buffer::from_raw(305398528_u64 as _),
			305398784_u64 as vk::DeviceSize,
			Default::default(),
			Default::default(),
		)
		.unwrap();
		vk::Device::cmd_draw_indirect_byte_count_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
			Default::default(),
			vk::Buffer::from_raw(305398528_u64 as _),
			305398784_u64 as vk::DeviceSize,
			Default::default(),
			Default::default(),
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_set_exclusive_scissor_nv_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, vk::CommandBuffer, u32, u32, *const vk::Rect2D) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_exclusive_scissor_nv;
	let _: Signature = vk::Device::cmd_set_exclusive_scissor_nv;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_exclusive_scissor_nv(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::Rect2D>()
			),
			Err(CallError::MissingCommand("vkCmdSetExclusiveScissorNV"))
		));
		assert!(matches!(
			fixture.device.cmd_set_exclusive_scissor_nv(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::Rect2D>()
			),
			Err(CallError::MissingCommand("vkCmdSetExclusiveScissorNV"))
		));
	}
}

#[test]
fn cmd_set_exclusive_scissor_nv_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: u32,
		arg_2: u32,
		arg_3: *const vk::Rect2D,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == Default::default()
					&& arg_2 == Default::default()
					&& std::ptr::eq(
						arg_3,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *const vk::Rect2D,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdSetExclusiveScissorNV = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdSetExclusiveScissorNV, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdSetExclusiveScissorNV", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_set_exclusive_scissor_nv(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *const vk::Rect2D,
		)
		.unwrap();
		vk::Device::cmd_set_exclusive_scissor_nv(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *const vk::Rect2D,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_set_exclusive_scissor_enable_nv_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, vk::CommandBuffer, u32, u32, *const vk::Bool32) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_exclusive_scissor_enable_nv;
	let _: Signature = vk::Device::cmd_set_exclusive_scissor_enable_nv;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_exclusive_scissor_enable_nv(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::Bool32>()
			),
			Err(CallError::MissingCommand(
				"vkCmdSetExclusiveScissorEnableNV"
			))
		));
		assert!(matches!(
			fixture.device.cmd_set_exclusive_scissor_enable_nv(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::Bool32>()
			),
			Err(CallError::MissingCommand(
				"vkCmdSetExclusiveScissorEnableNV"
			))
		));
	}
}

#[test]
fn cmd_set_exclusive_scissor_enable_nv_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: u32,
		arg_2: u32,
		arg_3: *const vk::Bool32,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == Default::default()
					&& arg_2 == Default::default()
					&& std::ptr::eq(
						arg_3,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *const vk::Bool32,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdSetExclusiveScissorEnableNV = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkCmdSetExclusiveScissorEnableNV,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdSetExclusiveScissorEnableNV", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_set_exclusive_scissor_enable_nv(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *const vk::Bool32,
		)
		.unwrap();
		vk::Device::cmd_set_exclusive_scissor_enable_nv(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *const vk::Bool32,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_bind_shading_rate_image_nv_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		vk::ImageView,
		vk::ImageLayout,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_bind_shading_rate_image_nv;
	let _: Signature = vk::Device::cmd_bind_shading_rate_image_nv;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_bind_shading_rate_image_nv(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::ImageView>(),
				std::mem::zeroed::<vk::ImageLayout>()
			),
			Err(CallError::MissingCommand("vkCmdBindShadingRateImageNV"))
		));
		assert!(matches!(
			fixture.device.cmd_bind_shading_rate_image_nv(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::ImageView>(),
				std::mem::zeroed::<vk::ImageLayout>()
			),
			Err(CallError::MissingCommand("vkCmdBindShadingRateImageNV"))
		));
	}
}

#[test]
fn cmd_bind_shading_rate_image_nv_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: vk::ImageView,
		arg_2: vk::ImageLayout,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == vk::ImageView::from_raw(305398016_u64 as _)
					&& arg_2 == vk::ImageLayout::from_raw(305398272_u64 as _)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdBindShadingRateImageNV = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdBindShadingRateImageNV, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdBindShadingRateImageNV", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_bind_shading_rate_image_nv(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::ImageView::from_raw(305398016_u64 as _),
			vk::ImageLayout::from_raw(305398272_u64 as _),
		)
		.unwrap();
		vk::Device::cmd_bind_shading_rate_image_nv(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::ImageView::from_raw(305398016_u64 as _),
			vk::ImageLayout::from_raw(305398272_u64 as _),
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_set_viewport_shading_rate_palette_nv_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		u32,
		u32,
		*const vk::ShadingRatePaletteNV<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_viewport_shading_rate_palette_nv;
	let _: Signature = vk::Device::cmd_set_viewport_shading_rate_palette_nv;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_viewport_shading_rate_palette_nv(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::ShadingRatePaletteNV<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkCmdSetViewportShadingRatePaletteNV"
			))
		));
		assert!(matches!(
			fixture.device.cmd_set_viewport_shading_rate_palette_nv(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::ShadingRatePaletteNV<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkCmdSetViewportShadingRatePaletteNV"
			))
		));
	}
}

#[test]
fn cmd_set_viewport_shading_rate_palette_nv_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: u32,
		arg_2: u32,
		arg_3: *const vk::ShadingRatePaletteNV<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == Default::default()
					&& arg_2 == Default::default()
					&& std::ptr::eq(
						arg_3,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
							as *const vk::ShadingRatePaletteNV<'_>,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdSetViewportShadingRatePaletteNV = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkCmdSetViewportShadingRatePaletteNV,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdSetViewportShadingRatePaletteNV", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_set_viewport_shading_rate_palette_nv(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
				as *const vk::ShadingRatePaletteNV<'_>,
		)
		.unwrap();
		vk::Device::cmd_set_viewport_shading_rate_palette_nv(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
				as *const vk::ShadingRatePaletteNV<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_set_coarse_sample_order_nv_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		vk::CoarseSampleOrderTypeNV,
		u32,
		*const vk::CoarseSampleOrderCustomNV<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_coarse_sample_order_nv;
	let _: Signature = vk::Device::cmd_set_coarse_sample_order_nv;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_coarse_sample_order_nv(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::CoarseSampleOrderTypeNV>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::CoarseSampleOrderCustomNV<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdSetCoarseSampleOrderNV"))
		));
		assert!(matches!(
			fixture.device.cmd_set_coarse_sample_order_nv(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::CoarseSampleOrderTypeNV>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::CoarseSampleOrderCustomNV<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdSetCoarseSampleOrderNV"))
		));
	}
}

#[test]
fn cmd_set_coarse_sample_order_nv_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: vk::CoarseSampleOrderTypeNV,
		arg_2: u32,
		arg_3: *const vk::CoarseSampleOrderCustomNV<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == vk::CoarseSampleOrderTypeNV::from_raw(305398016_u64 as _)
					&& arg_2 == Default::default()
					&& std::ptr::eq(
						arg_3,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
							as *const vk::CoarseSampleOrderCustomNV<'_>,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdSetCoarseSampleOrderNV = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdSetCoarseSampleOrderNV, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdSetCoarseSampleOrderNV", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_set_coarse_sample_order_nv(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::CoarseSampleOrderTypeNV::from_raw(305398016_u64 as _),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
				as *const vk::CoarseSampleOrderCustomNV<'_>,
		)
		.unwrap();
		vk::Device::cmd_set_coarse_sample_order_nv(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::CoarseSampleOrderTypeNV::from_raw(305398016_u64 as _),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
				as *const vk::CoarseSampleOrderCustomNV<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_draw_mesh_tasks_nv_signature_and_missing_command() {
	type Signature = unsafe fn(&vk::Device, vk::CommandBuffer, u32, u32) -> Result<(), CallError>;
	let _: Signature = vk::cmd_draw_mesh_tasks_nv;
	let _: Signature = vk::Device::cmd_draw_mesh_tasks_nv;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_draw_mesh_tasks_nv(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>()
			),
			Err(CallError::MissingCommand("vkCmdDrawMeshTasksNV"))
		));
		assert!(matches!(
			fixture.device.cmd_draw_mesh_tasks_nv(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>()
			),
			Err(CallError::MissingCommand("vkCmdDrawMeshTasksNV"))
		));
	}
}

#[test]
fn cmd_draw_mesh_tasks_nv_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::CommandBuffer, arg_1: u32, arg_2: u32) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == Default::default()
					&& arg_2 == Default::default()),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdDrawMeshTasksNV = Some(mock);
		let erased = std::mem::transmute::<vk::PFN_vkCmdDrawMeshTasksNV, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdDrawMeshTasksNV", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_draw_mesh_tasks_nv(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
			Default::default(),
		)
		.unwrap();
		vk::Device::cmd_draw_mesh_tasks_nv(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
			Default::default(),
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_draw_mesh_tasks_indirect_nv_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		vk::Buffer,
		vk::DeviceSize,
		u32,
		u32,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_draw_mesh_tasks_indirect_nv;
	let _: Signature = vk::Device::cmd_draw_mesh_tasks_indirect_nv;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_draw_mesh_tasks_indirect_nv(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::Buffer>(),
				std::mem::zeroed::<vk::DeviceSize>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>()
			),
			Err(CallError::MissingCommand("vkCmdDrawMeshTasksIndirectNV"))
		));
		assert!(matches!(
			fixture.device.cmd_draw_mesh_tasks_indirect_nv(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::Buffer>(),
				std::mem::zeroed::<vk::DeviceSize>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>()
			),
			Err(CallError::MissingCommand("vkCmdDrawMeshTasksIndirectNV"))
		));
	}
}

#[test]
fn cmd_draw_mesh_tasks_indirect_nv_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: vk::Buffer,
		arg_2: vk::DeviceSize,
		arg_3: u32,
		arg_4: u32,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == vk::Buffer::from_raw(305398016_u64 as _)
					&& arg_2 == 305398272_u64 as vk::DeviceSize
					&& arg_3 == Default::default()
					&& arg_4 == Default::default()),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdDrawMeshTasksIndirectNV = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdDrawMeshTasksIndirectNV, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdDrawMeshTasksIndirectNV", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_draw_mesh_tasks_indirect_nv(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::Buffer::from_raw(305398016_u64 as _),
			305398272_u64 as vk::DeviceSize,
			Default::default(),
			Default::default(),
		)
		.unwrap();
		vk::Device::cmd_draw_mesh_tasks_indirect_nv(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::Buffer::from_raw(305398016_u64 as _),
			305398272_u64 as vk::DeviceSize,
			Default::default(),
			Default::default(),
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_draw_mesh_tasks_indirect_count_nv_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		vk::Buffer,
		vk::DeviceSize,
		vk::Buffer,
		vk::DeviceSize,
		u32,
		u32,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_draw_mesh_tasks_indirect_count_nv;
	let _: Signature = vk::Device::cmd_draw_mesh_tasks_indirect_count_nv;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_draw_mesh_tasks_indirect_count_nv(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::Buffer>(),
				std::mem::zeroed::<vk::DeviceSize>(),
				std::mem::zeroed::<vk::Buffer>(),
				std::mem::zeroed::<vk::DeviceSize>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>()
			),
			Err(CallError::MissingCommand(
				"vkCmdDrawMeshTasksIndirectCountNV"
			))
		));
		assert!(matches!(
			fixture.device.cmd_draw_mesh_tasks_indirect_count_nv(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::Buffer>(),
				std::mem::zeroed::<vk::DeviceSize>(),
				std::mem::zeroed::<vk::Buffer>(),
				std::mem::zeroed::<vk::DeviceSize>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>()
			),
			Err(CallError::MissingCommand(
				"vkCmdDrawMeshTasksIndirectCountNV"
			))
		));
	}
}

#[test]
fn cmd_draw_mesh_tasks_indirect_count_nv_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: vk::Buffer,
		arg_2: vk::DeviceSize,
		arg_3: vk::Buffer,
		arg_4: vk::DeviceSize,
		arg_5: u32,
		arg_6: u32,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == vk::Buffer::from_raw(305398016_u64 as _)
					&& arg_2 == 305398272_u64 as vk::DeviceSize
					&& arg_3 == vk::Buffer::from_raw(305398528_u64 as _)
					&& arg_4 == 305398784_u64 as vk::DeviceSize
					&& arg_5 == Default::default()
					&& arg_6 == Default::default()),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdDrawMeshTasksIndirectCountNV = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkCmdDrawMeshTasksIndirectCountNV,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdDrawMeshTasksIndirectCountNV", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_draw_mesh_tasks_indirect_count_nv(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::Buffer::from_raw(305398016_u64 as _),
			305398272_u64 as vk::DeviceSize,
			vk::Buffer::from_raw(305398528_u64 as _),
			305398784_u64 as vk::DeviceSize,
			Default::default(),
			Default::default(),
		)
		.unwrap();
		vk::Device::cmd_draw_mesh_tasks_indirect_count_nv(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::Buffer::from_raw(305398016_u64 as _),
			305398272_u64 as vk::DeviceSize,
			vk::Buffer::from_raw(305398528_u64 as _),
			305398784_u64 as vk::DeviceSize,
			Default::default(),
			Default::default(),
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_draw_mesh_tasks_ext_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, vk::CommandBuffer, u32, u32, u32) -> Result<(), CallError>;
	let _: Signature = vk::cmd_draw_mesh_tasks_ext;
	let _: Signature = vk::Device::cmd_draw_mesh_tasks_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_draw_mesh_tasks_ext(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>()
			),
			Err(CallError::MissingCommand("vkCmdDrawMeshTasksEXT"))
		));
		assert!(matches!(
			fixture.device.cmd_draw_mesh_tasks_ext(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>()
			),
			Err(CallError::MissingCommand("vkCmdDrawMeshTasksEXT"))
		));
	}
}

#[test]
fn cmd_draw_mesh_tasks_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::CommandBuffer, arg_1: u32, arg_2: u32, arg_3: u32) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == Default::default()
					&& arg_2 == Default::default()
					&& arg_3 == Default::default()),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdDrawMeshTasksEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdDrawMeshTasksEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdDrawMeshTasksEXT", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_draw_mesh_tasks_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
			Default::default(),
			Default::default(),
		)
		.unwrap();
		vk::Device::cmd_draw_mesh_tasks_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
			Default::default(),
			Default::default(),
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_draw_mesh_tasks_indirect_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		vk::Buffer,
		vk::DeviceSize,
		u32,
		u32,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_draw_mesh_tasks_indirect_ext;
	let _: Signature = vk::Device::cmd_draw_mesh_tasks_indirect_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_draw_mesh_tasks_indirect_ext(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::Buffer>(),
				std::mem::zeroed::<vk::DeviceSize>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>()
			),
			Err(CallError::MissingCommand("vkCmdDrawMeshTasksIndirectEXT"))
		));
		assert!(matches!(
			fixture.device.cmd_draw_mesh_tasks_indirect_ext(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::Buffer>(),
				std::mem::zeroed::<vk::DeviceSize>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>()
			),
			Err(CallError::MissingCommand("vkCmdDrawMeshTasksIndirectEXT"))
		));
	}
}

#[test]
fn cmd_draw_mesh_tasks_indirect_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: vk::Buffer,
		arg_2: vk::DeviceSize,
		arg_3: u32,
		arg_4: u32,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == vk::Buffer::from_raw(305398016_u64 as _)
					&& arg_2 == 305398272_u64 as vk::DeviceSize
					&& arg_3 == Default::default()
					&& arg_4 == Default::default()),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdDrawMeshTasksIndirectEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdDrawMeshTasksIndirectEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdDrawMeshTasksIndirectEXT", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_draw_mesh_tasks_indirect_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::Buffer::from_raw(305398016_u64 as _),
			305398272_u64 as vk::DeviceSize,
			Default::default(),
			Default::default(),
		)
		.unwrap();
		vk::Device::cmd_draw_mesh_tasks_indirect_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::Buffer::from_raw(305398016_u64 as _),
			305398272_u64 as vk::DeviceSize,
			Default::default(),
			Default::default(),
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_draw_mesh_tasks_indirect_count_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		vk::Buffer,
		vk::DeviceSize,
		vk::Buffer,
		vk::DeviceSize,
		u32,
		u32,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_draw_mesh_tasks_indirect_count_ext;
	let _: Signature = vk::Device::cmd_draw_mesh_tasks_indirect_count_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_draw_mesh_tasks_indirect_count_ext(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::Buffer>(),
				std::mem::zeroed::<vk::DeviceSize>(),
				std::mem::zeroed::<vk::Buffer>(),
				std::mem::zeroed::<vk::DeviceSize>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>()
			),
			Err(CallError::MissingCommand(
				"vkCmdDrawMeshTasksIndirectCountEXT"
			))
		));
		assert!(matches!(
			fixture.device.cmd_draw_mesh_tasks_indirect_count_ext(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::Buffer>(),
				std::mem::zeroed::<vk::DeviceSize>(),
				std::mem::zeroed::<vk::Buffer>(),
				std::mem::zeroed::<vk::DeviceSize>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>()
			),
			Err(CallError::MissingCommand(
				"vkCmdDrawMeshTasksIndirectCountEXT"
			))
		));
	}
}

#[test]
fn cmd_draw_mesh_tasks_indirect_count_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: vk::Buffer,
		arg_2: vk::DeviceSize,
		arg_3: vk::Buffer,
		arg_4: vk::DeviceSize,
		arg_5: u32,
		arg_6: u32,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == vk::Buffer::from_raw(305398016_u64 as _)
					&& arg_2 == 305398272_u64 as vk::DeviceSize
					&& arg_3 == vk::Buffer::from_raw(305398528_u64 as _)
					&& arg_4 == 305398784_u64 as vk::DeviceSize
					&& arg_5 == Default::default()
					&& arg_6 == Default::default()),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdDrawMeshTasksIndirectCountEXT = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkCmdDrawMeshTasksIndirectCountEXT,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdDrawMeshTasksIndirectCountEXT", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_draw_mesh_tasks_indirect_count_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::Buffer::from_raw(305398016_u64 as _),
			305398272_u64 as vk::DeviceSize,
			vk::Buffer::from_raw(305398528_u64 as _),
			305398784_u64 as vk::DeviceSize,
			Default::default(),
			Default::default(),
		)
		.unwrap();
		vk::Device::cmd_draw_mesh_tasks_indirect_count_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::Buffer::from_raw(305398016_u64 as _),
			305398272_u64 as vk::DeviceSize,
			vk::Buffer::from_raw(305398528_u64 as _),
			305398784_u64 as vk::DeviceSize,
			Default::default(),
			Default::default(),
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn compile_deferred_nv_signature_and_missing_command() {
	type Signature = unsafe fn(&vk::Device, vk::Pipeline, u32) -> Result<vk::Result, CallError>;
	let _: Signature = vk::compile_deferred_nv;
	let _: Signature = vk::Device::compile_deferred_nv;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::compile_deferred_nv(
				&fixture.device,
				std::mem::zeroed::<vk::Pipeline>(),
				std::mem::zeroed::<u32>()
			),
			Err(CallError::MissingCommand("vkCompileDeferredNV"))
		));
		assert!(matches!(
			fixture.device.compile_deferred_nv(
				std::mem::zeroed::<vk::Pipeline>(),
				std::mem::zeroed::<u32>()
			),
			Err(CallError::MissingCommand("vkCompileDeferredNV"))
		));
	}
}

#[test]
fn compile_deferred_nv_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::Pipeline,
		arg_2: u32,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::Pipeline::from_raw(305398016_u64 as _)
					&& arg_2 == Default::default()),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCompileDeferredNV = Some(mock);
		let erased = std::mem::transmute::<vk::PFN_vkCompileDeferredNV, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCompileDeferredNV", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::compile_deferred_nv(
					&fixture.device,
					vk::Pipeline::from_raw(305398016_u64 as _),
					Default::default()
				),
				expected
			);
			assert_eq!(
				vk::Device::compile_deferred_nv(
					&fixture.device,
					vk::Pipeline::from_raw(305398016_u64 as _),
					Default::default()
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn create_acceleration_structure_nv_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::AccelerationStructureCreateInfoNV<'_>,
		*const vk::AllocationCallbacks,
		*mut vk::AccelerationStructureNV,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::create_acceleration_structure_nv;
	let _: Signature = vk::Device::create_acceleration_structure_nv;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::create_acceleration_structure_nv(
				&fixture.device,
				std::mem::zeroed::<*const vk::AccelerationStructureCreateInfoNV<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::AccelerationStructureNV>()
			),
			Err(CallError::MissingCommand("vkCreateAccelerationStructureNV"))
		));
		assert!(matches!(
			fixture.device.create_acceleration_structure_nv(
				std::mem::zeroed::<*const vk::AccelerationStructureCreateInfoNV<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::AccelerationStructureNV>()
			),
			Err(CallError::MissingCommand("vkCreateAccelerationStructureNV"))
		));
	}
}

#[test]
fn create_acceleration_structure_nv_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::AccelerationStructureCreateInfoNV<'_>,
		arg_2: *const vk::AllocationCallbacks,
		arg_3: *mut vk::AccelerationStructureNV,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::AccelerationStructureCreateInfoNV<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
				) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::AccelerationStructureNV,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCreateAccelerationStructureNV = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCreateAccelerationStructureNV, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCreateAccelerationStructureNV", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::create_acceleration_structure_nv(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::AccelerationStructureCreateInfoNV<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::AccelerationStructureNV
				),
				expected
			);
			assert_eq!(
				vk::Device::create_acceleration_structure_nv(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::AccelerationStructureCreateInfoNV<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::AccelerationStructureNV
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_bind_invocation_mask_huawei_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		vk::ImageView,
		vk::ImageLayout,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_bind_invocation_mask_huawei;
	let _: Signature = vk::Device::cmd_bind_invocation_mask_huawei;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_bind_invocation_mask_huawei(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::ImageView>(),
				std::mem::zeroed::<vk::ImageLayout>()
			),
			Err(CallError::MissingCommand("vkCmdBindInvocationMaskHUAWEI"))
		));
		assert!(matches!(
			fixture.device.cmd_bind_invocation_mask_huawei(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::ImageView>(),
				std::mem::zeroed::<vk::ImageLayout>()
			),
			Err(CallError::MissingCommand("vkCmdBindInvocationMaskHUAWEI"))
		));
	}
}

#[test]
fn cmd_bind_invocation_mask_huawei_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: vk::ImageView,
		arg_2: vk::ImageLayout,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == vk::ImageView::from_raw(305398016_u64 as _)
					&& arg_2 == vk::ImageLayout::from_raw(305398272_u64 as _)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdBindInvocationMaskHUAWEI = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdBindInvocationMaskHUAWEI, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdBindInvocationMaskHUAWEI", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_bind_invocation_mask_huawei(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::ImageView::from_raw(305398016_u64 as _),
			vk::ImageLayout::from_raw(305398272_u64 as _),
		)
		.unwrap();
		vk::Device::cmd_bind_invocation_mask_huawei(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::ImageView::from_raw(305398016_u64 as _),
			vk::ImageLayout::from_raw(305398272_u64 as _),
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn destroy_acceleration_structure_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::AccelerationStructureKHR,
		*const vk::AllocationCallbacks,
	) -> Result<(), CallError>;
	let _: Signature = vk::destroy_acceleration_structure_khr;
	let _: Signature = vk::Device::destroy_acceleration_structure_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::destroy_acceleration_structure_khr(
				&fixture.device,
				std::mem::zeroed::<vk::AccelerationStructureKHR>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>()
			),
			Err(CallError::MissingCommand(
				"vkDestroyAccelerationStructureKHR"
			))
		));
		assert!(matches!(
			fixture.device.destroy_acceleration_structure_khr(
				std::mem::zeroed::<vk::AccelerationStructureKHR>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>()
			),
			Err(CallError::MissingCommand(
				"vkDestroyAccelerationStructureKHR"
			))
		));
	}
}

#[test]
fn destroy_acceleration_structure_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::AccelerationStructureKHR,
		arg_2: *const vk::AllocationCallbacks,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::AccelerationStructureKHR::from_raw(305398016_u64 as _)
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *const vk::AllocationCallbacks,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkDestroyAccelerationStructureKHR = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkDestroyAccelerationStructureKHR,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkDestroyAccelerationStructureKHR", erased);
		let resolutions = Fixture::query_count();
		vk::destroy_acceleration_structure_khr(
			&fixture.device,
			vk::AccelerationStructureKHR::from_raw(305398016_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::AllocationCallbacks,
		)
		.unwrap();
		vk::Device::destroy_acceleration_structure_khr(
			&fixture.device,
			vk::AccelerationStructureKHR::from_raw(305398016_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::AllocationCallbacks,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn destroy_acceleration_structure_nv_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::AccelerationStructureNV,
		*const vk::AllocationCallbacks,
	) -> Result<(), CallError>;
	let _: Signature = vk::destroy_acceleration_structure_nv;
	let _: Signature = vk::Device::destroy_acceleration_structure_nv;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::destroy_acceleration_structure_nv(
				&fixture.device,
				std::mem::zeroed::<vk::AccelerationStructureNV>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>()
			),
			Err(CallError::MissingCommand(
				"vkDestroyAccelerationStructureNV"
			))
		));
		assert!(matches!(
			fixture.device.destroy_acceleration_structure_nv(
				std::mem::zeroed::<vk::AccelerationStructureNV>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>()
			),
			Err(CallError::MissingCommand(
				"vkDestroyAccelerationStructureNV"
			))
		));
	}
}

#[test]
fn destroy_acceleration_structure_nv_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::AccelerationStructureNV,
		arg_2: *const vk::AllocationCallbacks,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::AccelerationStructureNV::from_raw(305398016_u64 as _)
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *const vk::AllocationCallbacks,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkDestroyAccelerationStructureNV = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkDestroyAccelerationStructureNV,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkDestroyAccelerationStructureNV", erased);
		let resolutions = Fixture::query_count();
		vk::destroy_acceleration_structure_nv(
			&fixture.device,
			vk::AccelerationStructureNV::from_raw(305398016_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::AllocationCallbacks,
		)
		.unwrap();
		vk::Device::destroy_acceleration_structure_nv(
			&fixture.device,
			vk::AccelerationStructureNV::from_raw(305398016_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::AllocationCallbacks,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_acceleration_structure_memory_requirements_nv_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::AccelerationStructureMemoryRequirementsInfoNV<'_>,
		*mut vk::MemoryRequirements2<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::get_acceleration_structure_memory_requirements_nv;
	let _: Signature = vk::Device::get_acceleration_structure_memory_requirements_nv;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_acceleration_structure_memory_requirements_nv(
				&fixture.device,
				std::mem::zeroed::<*const vk::AccelerationStructureMemoryRequirementsInfoNV<'_>>(),
				std::mem::zeroed::<*mut vk::MemoryRequirements2<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetAccelerationStructureMemoryRequirementsNV"
			))
		));
		assert!(matches!(
			fixture
				.device
				.get_acceleration_structure_memory_requirements_nv(
					std::mem::zeroed::<*const vk::AccelerationStructureMemoryRequirementsInfoNV<'_>>(),
					std::mem::zeroed::<*mut vk::MemoryRequirements2<'_>>()
				),
			Err(CallError::MissingCommand(
				"vkGetAccelerationStructureMemoryRequirementsNV"
			))
		));
	}
}

#[test]
fn get_acceleration_structure_memory_requirements_nv_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::AccelerationStructureMemoryRequirementsInfoNV<'_>,
		arg_2: *mut vk::MemoryRequirements2<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::AccelerationStructureMemoryRequirementsInfoNV<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::MemoryRequirements2<'_>,
				)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetAccelerationStructureMemoryRequirementsNV = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetAccelerationStructureMemoryRequirementsNV,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture =
			Fixture::new_with_command(c"vkGetAccelerationStructureMemoryRequirementsNV", erased);
		let resolutions = Fixture::query_count();
		vk::get_acceleration_structure_memory_requirements_nv(
			&fixture.device,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::AccelerationStructureMemoryRequirementsInfoNV<'_>,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *mut vk::MemoryRequirements2<'_>,
		)
		.unwrap();
		vk::Device::get_acceleration_structure_memory_requirements_nv(
			&fixture.device,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::AccelerationStructureMemoryRequirementsInfoNV<'_>,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *mut vk::MemoryRequirements2<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn bind_acceleration_structure_memory_nv_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		u32,
		*const vk::BindAccelerationStructureMemoryInfoNV<'_>,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::bind_acceleration_structure_memory_nv;
	let _: Signature = vk::Device::bind_acceleration_structure_memory_nv;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::bind_acceleration_structure_memory_nv(
				&fixture.device,
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::BindAccelerationStructureMemoryInfoNV<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkBindAccelerationStructureMemoryNV"
			))
		));
		assert!(matches!(
			fixture.device.bind_acceleration_structure_memory_nv(
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::BindAccelerationStructureMemoryInfoNV<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkBindAccelerationStructureMemoryNV"
			))
		));
	}
}

#[test]
fn bind_acceleration_structure_memory_nv_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: u32,
		arg_2: *const vk::BindAccelerationStructureMemoryInfoNV<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == Default::default()
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *const vk::BindAccelerationStructureMemoryInfoNV<'_>,
					)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkBindAccelerationStructureMemoryNV = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkBindAccelerationStructureMemoryNV,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkBindAccelerationStructureMemoryNV", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::bind_acceleration_structure_memory_nv(
					&fixture.device,
					Default::default(),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::BindAccelerationStructureMemoryInfoNV<'_>
				),
				expected
			);
			assert_eq!(
				vk::Device::bind_acceleration_structure_memory_nv(
					&fixture.device,
					Default::default(),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::BindAccelerationStructureMemoryInfoNV<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_copy_acceleration_structure_nv_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		vk::AccelerationStructureNV,
		vk::AccelerationStructureNV,
		vk::CopyAccelerationStructureModeKHR,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_copy_acceleration_structure_nv;
	let _: Signature = vk::Device::cmd_copy_acceleration_structure_nv;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_copy_acceleration_structure_nv(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::AccelerationStructureNV>(),
				std::mem::zeroed::<vk::AccelerationStructureNV>(),
				std::mem::zeroed::<vk::CopyAccelerationStructureModeKHR>()
			),
			Err(CallError::MissingCommand(
				"vkCmdCopyAccelerationStructureNV"
			))
		));
		assert!(matches!(
			fixture.device.cmd_copy_acceleration_structure_nv(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::AccelerationStructureNV>(),
				std::mem::zeroed::<vk::AccelerationStructureNV>(),
				std::mem::zeroed::<vk::CopyAccelerationStructureModeKHR>()
			),
			Err(CallError::MissingCommand(
				"vkCmdCopyAccelerationStructureNV"
			))
		));
	}
}

#[test]
fn cmd_copy_acceleration_structure_nv_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: vk::AccelerationStructureNV,
		arg_2: vk::AccelerationStructureNV,
		arg_3: vk::CopyAccelerationStructureModeKHR,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == vk::AccelerationStructureNV::from_raw(305398016_u64 as _)
					&& arg_2 == vk::AccelerationStructureNV::from_raw(305398272_u64 as _)
					&& arg_3 == vk::CopyAccelerationStructureModeKHR::from_raw(305398528_u64 as _)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdCopyAccelerationStructureNV = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkCmdCopyAccelerationStructureNV,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdCopyAccelerationStructureNV", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_copy_acceleration_structure_nv(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::AccelerationStructureNV::from_raw(305398016_u64 as _),
			vk::AccelerationStructureNV::from_raw(305398272_u64 as _),
			vk::CopyAccelerationStructureModeKHR::from_raw(305398528_u64 as _),
		)
		.unwrap();
		vk::Device::cmd_copy_acceleration_structure_nv(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::AccelerationStructureNV::from_raw(305398016_u64 as _),
			vk::AccelerationStructureNV::from_raw(305398272_u64 as _),
			vk::CopyAccelerationStructureModeKHR::from_raw(305398528_u64 as _),
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_copy_acceleration_structure_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		*const vk::CopyAccelerationStructureInfoKHR<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_copy_acceleration_structure_khr;
	let _: Signature = vk::Device::cmd_copy_acceleration_structure_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_copy_acceleration_structure_khr(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::CopyAccelerationStructureInfoKHR<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkCmdCopyAccelerationStructureKHR"
			))
		));
		assert!(matches!(
			fixture.device.cmd_copy_acceleration_structure_khr(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::CopyAccelerationStructureInfoKHR<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkCmdCopyAccelerationStructureKHR"
			))
		));
	}
}

#[test]
fn cmd_copy_acceleration_structure_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: *const vk::CopyAccelerationStructureInfoKHR<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::CopyAccelerationStructureInfoKHR<'_>,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdCopyAccelerationStructureKHR = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkCmdCopyAccelerationStructureKHR,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdCopyAccelerationStructureKHR", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_copy_acceleration_structure_khr(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::CopyAccelerationStructureInfoKHR<'_>,
		)
		.unwrap();
		vk::Device::cmd_copy_acceleration_structure_khr(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::CopyAccelerationStructureInfoKHR<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn copy_acceleration_structure_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::DeferredOperationKHR,
		*const vk::CopyAccelerationStructureInfoKHR<'_>,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::copy_acceleration_structure_khr;
	let _: Signature = vk::Device::copy_acceleration_structure_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::copy_acceleration_structure_khr(
				&fixture.device,
				std::mem::zeroed::<vk::DeferredOperationKHR>(),
				std::mem::zeroed::<*const vk::CopyAccelerationStructureInfoKHR<'_>>()
			),
			Err(CallError::MissingCommand("vkCopyAccelerationStructureKHR"))
		));
		assert!(matches!(
			fixture.device.copy_acceleration_structure_khr(
				std::mem::zeroed::<vk::DeferredOperationKHR>(),
				std::mem::zeroed::<*const vk::CopyAccelerationStructureInfoKHR<'_>>()
			),
			Err(CallError::MissingCommand("vkCopyAccelerationStructureKHR"))
		));
	}
}

#[test]
fn copy_acceleration_structure_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::DeferredOperationKHR,
		arg_2: *const vk::CopyAccelerationStructureInfoKHR<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::DeferredOperationKHR::from_raw(305398016_u64 as _)
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *const vk::CopyAccelerationStructureInfoKHR<'_>,
					)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCopyAccelerationStructureKHR = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCopyAccelerationStructureKHR, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCopyAccelerationStructureKHR", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::copy_acceleration_structure_khr(
					&fixture.device,
					vk::DeferredOperationKHR::from_raw(305398016_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::CopyAccelerationStructureInfoKHR<'_>
				),
				expected
			);
			assert_eq!(
				vk::Device::copy_acceleration_structure_khr(
					&fixture.device,
					vk::DeferredOperationKHR::from_raw(305398016_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::CopyAccelerationStructureInfoKHR<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_copy_acceleration_structure_to_memory_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		*const vk::CopyAccelerationStructureToMemoryInfoKHR<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_copy_acceleration_structure_to_memory_khr;
	let _: Signature = vk::Device::cmd_copy_acceleration_structure_to_memory_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_copy_acceleration_structure_to_memory_khr(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::CopyAccelerationStructureToMemoryInfoKHR<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkCmdCopyAccelerationStructureToMemoryKHR"
			))
		));
		assert!(matches!(
			fixture
				.device
				.cmd_copy_acceleration_structure_to_memory_khr(
					std::mem::zeroed::<vk::CommandBuffer>(),
					std::mem::zeroed::<*const vk::CopyAccelerationStructureToMemoryInfoKHR<'_>>()
				),
			Err(CallError::MissingCommand(
				"vkCmdCopyAccelerationStructureToMemoryKHR"
			))
		));
	}
}

#[test]
fn cmd_copy_acceleration_structure_to_memory_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: *const vk::CopyAccelerationStructureToMemoryInfoKHR<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::CopyAccelerationStructureToMemoryInfoKHR<'_>,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdCopyAccelerationStructureToMemoryKHR = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkCmdCopyAccelerationStructureToMemoryKHR,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdCopyAccelerationStructureToMemoryKHR", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_copy_acceleration_structure_to_memory_khr(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::CopyAccelerationStructureToMemoryInfoKHR<'_>,
		)
		.unwrap();
		vk::Device::cmd_copy_acceleration_structure_to_memory_khr(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::CopyAccelerationStructureToMemoryInfoKHR<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn copy_acceleration_structure_to_memory_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::DeferredOperationKHR,
		*const vk::CopyAccelerationStructureToMemoryInfoKHR<'_>,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::copy_acceleration_structure_to_memory_khr;
	let _: Signature = vk::Device::copy_acceleration_structure_to_memory_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::copy_acceleration_structure_to_memory_khr(
				&fixture.device,
				std::mem::zeroed::<vk::DeferredOperationKHR>(),
				std::mem::zeroed::<*const vk::CopyAccelerationStructureToMemoryInfoKHR<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkCopyAccelerationStructureToMemoryKHR"
			))
		));
		assert!(matches!(
			fixture.device.copy_acceleration_structure_to_memory_khr(
				std::mem::zeroed::<vk::DeferredOperationKHR>(),
				std::mem::zeroed::<*const vk::CopyAccelerationStructureToMemoryInfoKHR<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkCopyAccelerationStructureToMemoryKHR"
			))
		));
	}
}

#[test]
fn copy_acceleration_structure_to_memory_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::DeferredOperationKHR,
		arg_2: *const vk::CopyAccelerationStructureToMemoryInfoKHR<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::DeferredOperationKHR::from_raw(305398016_u64 as _)
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *const vk::CopyAccelerationStructureToMemoryInfoKHR<'_>,
					)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCopyAccelerationStructureToMemoryKHR = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkCopyAccelerationStructureToMemoryKHR,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkCopyAccelerationStructureToMemoryKHR", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::copy_acceleration_structure_to_memory_khr(
					&fixture.device,
					vk::DeferredOperationKHR::from_raw(305398016_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::CopyAccelerationStructureToMemoryInfoKHR<'_>
				),
				expected
			);
			assert_eq!(
				vk::Device::copy_acceleration_structure_to_memory_khr(
					&fixture.device,
					vk::DeferredOperationKHR::from_raw(305398016_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::CopyAccelerationStructureToMemoryInfoKHR<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_copy_memory_to_acceleration_structure_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		*const vk::CopyMemoryToAccelerationStructureInfoKHR<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_copy_memory_to_acceleration_structure_khr;
	let _: Signature = vk::Device::cmd_copy_memory_to_acceleration_structure_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_copy_memory_to_acceleration_structure_khr(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::CopyMemoryToAccelerationStructureInfoKHR<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkCmdCopyMemoryToAccelerationStructureKHR"
			))
		));
		assert!(matches!(
			fixture
				.device
				.cmd_copy_memory_to_acceleration_structure_khr(
					std::mem::zeroed::<vk::CommandBuffer>(),
					std::mem::zeroed::<*const vk::CopyMemoryToAccelerationStructureInfoKHR<'_>>()
				),
			Err(CallError::MissingCommand(
				"vkCmdCopyMemoryToAccelerationStructureKHR"
			))
		));
	}
}

#[test]
fn cmd_copy_memory_to_acceleration_structure_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: *const vk::CopyMemoryToAccelerationStructureInfoKHR<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::CopyMemoryToAccelerationStructureInfoKHR<'_>,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdCopyMemoryToAccelerationStructureKHR = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkCmdCopyMemoryToAccelerationStructureKHR,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdCopyMemoryToAccelerationStructureKHR", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_copy_memory_to_acceleration_structure_khr(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::CopyMemoryToAccelerationStructureInfoKHR<'_>,
		)
		.unwrap();
		vk::Device::cmd_copy_memory_to_acceleration_structure_khr(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::CopyMemoryToAccelerationStructureInfoKHR<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn copy_memory_to_acceleration_structure_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::DeferredOperationKHR,
		*const vk::CopyMemoryToAccelerationStructureInfoKHR<'_>,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::copy_memory_to_acceleration_structure_khr;
	let _: Signature = vk::Device::copy_memory_to_acceleration_structure_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::copy_memory_to_acceleration_structure_khr(
				&fixture.device,
				std::mem::zeroed::<vk::DeferredOperationKHR>(),
				std::mem::zeroed::<*const vk::CopyMemoryToAccelerationStructureInfoKHR<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkCopyMemoryToAccelerationStructureKHR"
			))
		));
		assert!(matches!(
			fixture.device.copy_memory_to_acceleration_structure_khr(
				std::mem::zeroed::<vk::DeferredOperationKHR>(),
				std::mem::zeroed::<*const vk::CopyMemoryToAccelerationStructureInfoKHR<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkCopyMemoryToAccelerationStructureKHR"
			))
		));
	}
}

#[test]
fn copy_memory_to_acceleration_structure_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::DeferredOperationKHR,
		arg_2: *const vk::CopyMemoryToAccelerationStructureInfoKHR<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::DeferredOperationKHR::from_raw(305398016_u64 as _)
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *const vk::CopyMemoryToAccelerationStructureInfoKHR<'_>,
					)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCopyMemoryToAccelerationStructureKHR = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkCopyMemoryToAccelerationStructureKHR,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkCopyMemoryToAccelerationStructureKHR", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::copy_memory_to_acceleration_structure_khr(
					&fixture.device,
					vk::DeferredOperationKHR::from_raw(305398016_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::CopyMemoryToAccelerationStructureInfoKHR<'_>
				),
				expected
			);
			assert_eq!(
				vk::Device::copy_memory_to_acceleration_structure_khr(
					&fixture.device,
					vk::DeferredOperationKHR::from_raw(305398016_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::CopyMemoryToAccelerationStructureInfoKHR<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_write_acceleration_structures_properties_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		u32,
		*const vk::AccelerationStructureKHR,
		vk::QueryType,
		vk::QueryPool,
		u32,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_write_acceleration_structures_properties_khr;
	let _: Signature = vk::Device::cmd_write_acceleration_structures_properties_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_write_acceleration_structures_properties_khr(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::AccelerationStructureKHR>(),
				std::mem::zeroed::<vk::QueryType>(),
				std::mem::zeroed::<vk::QueryPool>(),
				std::mem::zeroed::<u32>()
			),
			Err(CallError::MissingCommand(
				"vkCmdWriteAccelerationStructuresPropertiesKHR"
			))
		));
		assert!(matches!(
			fixture
				.device
				.cmd_write_acceleration_structures_properties_khr(
					std::mem::zeroed::<vk::CommandBuffer>(),
					std::mem::zeroed::<u32>(),
					std::mem::zeroed::<*const vk::AccelerationStructureKHR>(),
					std::mem::zeroed::<vk::QueryType>(),
					std::mem::zeroed::<vk::QueryPool>(),
					std::mem::zeroed::<u32>()
				),
			Err(CallError::MissingCommand(
				"vkCmdWriteAccelerationStructuresPropertiesKHR"
			))
		));
	}
}

#[test]
fn cmd_write_acceleration_structures_properties_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: u32,
		arg_2: *const vk::AccelerationStructureKHR,
		arg_3: vk::QueryType,
		arg_4: vk::QueryPool,
		arg_5: u32,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == Default::default()
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *const vk::AccelerationStructureKHR,
					) && arg_3 == vk::QueryType::from_raw(305398528_u64 as _)
					&& arg_4 == vk::QueryPool::from_raw(305398784_u64 as _)
					&& arg_5 == Default::default()),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdWriteAccelerationStructuresPropertiesKHR = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkCmdWriteAccelerationStructuresPropertiesKHR,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture =
			Fixture::new_with_command(c"vkCmdWriteAccelerationStructuresPropertiesKHR", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_write_acceleration_structures_properties_khr(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::AccelerationStructureKHR,
			vk::QueryType::from_raw(305398528_u64 as _),
			vk::QueryPool::from_raw(305398784_u64 as _),
			Default::default(),
		)
		.unwrap();
		vk::Device::cmd_write_acceleration_structures_properties_khr(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::AccelerationStructureKHR,
			vk::QueryType::from_raw(305398528_u64 as _),
			vk::QueryPool::from_raw(305398784_u64 as _),
			Default::default(),
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_write_acceleration_structures_properties_nv_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		u32,
		*const vk::AccelerationStructureNV,
		vk::QueryType,
		vk::QueryPool,
		u32,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_write_acceleration_structures_properties_nv;
	let _: Signature = vk::Device::cmd_write_acceleration_structures_properties_nv;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_write_acceleration_structures_properties_nv(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::AccelerationStructureNV>(),
				std::mem::zeroed::<vk::QueryType>(),
				std::mem::zeroed::<vk::QueryPool>(),
				std::mem::zeroed::<u32>()
			),
			Err(CallError::MissingCommand(
				"vkCmdWriteAccelerationStructuresPropertiesNV"
			))
		));
		assert!(matches!(
			fixture
				.device
				.cmd_write_acceleration_structures_properties_nv(
					std::mem::zeroed::<vk::CommandBuffer>(),
					std::mem::zeroed::<u32>(),
					std::mem::zeroed::<*const vk::AccelerationStructureNV>(),
					std::mem::zeroed::<vk::QueryType>(),
					std::mem::zeroed::<vk::QueryPool>(),
					std::mem::zeroed::<u32>()
				),
			Err(CallError::MissingCommand(
				"vkCmdWriteAccelerationStructuresPropertiesNV"
			))
		));
	}
}

#[test]
fn cmd_write_acceleration_structures_properties_nv_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: u32,
		arg_2: *const vk::AccelerationStructureNV,
		arg_3: vk::QueryType,
		arg_4: vk::QueryPool,
		arg_5: u32,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == Default::default()
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *const vk::AccelerationStructureNV,
					) && arg_3 == vk::QueryType::from_raw(305398528_u64 as _)
					&& arg_4 == vk::QueryPool::from_raw(305398784_u64 as _)
					&& arg_5 == Default::default()),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdWriteAccelerationStructuresPropertiesNV = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkCmdWriteAccelerationStructuresPropertiesNV,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture =
			Fixture::new_with_command(c"vkCmdWriteAccelerationStructuresPropertiesNV", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_write_acceleration_structures_properties_nv(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::AccelerationStructureNV,
			vk::QueryType::from_raw(305398528_u64 as _),
			vk::QueryPool::from_raw(305398784_u64 as _),
			Default::default(),
		)
		.unwrap();
		vk::Device::cmd_write_acceleration_structures_properties_nv(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::AccelerationStructureNV,
			vk::QueryType::from_raw(305398528_u64 as _),
			vk::QueryPool::from_raw(305398784_u64 as _),
			Default::default(),
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_build_acceleration_structure_nv_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		*const vk::AccelerationStructureInfoNV<'_>,
		vk::Buffer,
		vk::DeviceSize,
		vk::Bool32,
		vk::AccelerationStructureNV,
		vk::AccelerationStructureNV,
		vk::Buffer,
		vk::DeviceSize,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_build_acceleration_structure_nv;
	let _: Signature = vk::Device::cmd_build_acceleration_structure_nv;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_build_acceleration_structure_nv(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::AccelerationStructureInfoNV<'_>>(),
				std::mem::zeroed::<vk::Buffer>(),
				std::mem::zeroed::<vk::DeviceSize>(),
				std::mem::zeroed::<vk::Bool32>(),
				std::mem::zeroed::<vk::AccelerationStructureNV>(),
				std::mem::zeroed::<vk::AccelerationStructureNV>(),
				std::mem::zeroed::<vk::Buffer>(),
				std::mem::zeroed::<vk::DeviceSize>()
			),
			Err(CallError::MissingCommand(
				"vkCmdBuildAccelerationStructureNV"
			))
		));
		assert!(matches!(
			fixture.device.cmd_build_acceleration_structure_nv(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::AccelerationStructureInfoNV<'_>>(),
				std::mem::zeroed::<vk::Buffer>(),
				std::mem::zeroed::<vk::DeviceSize>(),
				std::mem::zeroed::<vk::Bool32>(),
				std::mem::zeroed::<vk::AccelerationStructureNV>(),
				std::mem::zeroed::<vk::AccelerationStructureNV>(),
				std::mem::zeroed::<vk::Buffer>(),
				std::mem::zeroed::<vk::DeviceSize>()
			),
			Err(CallError::MissingCommand(
				"vkCmdBuildAccelerationStructureNV"
			))
		));
	}
}

#[test]
fn cmd_build_acceleration_structure_nv_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }

	#[allow(clippy::too_many_arguments)]
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: *const vk::AccelerationStructureInfoNV<'_>,
		arg_2: vk::Buffer,
		arg_3: vk::DeviceSize,
		arg_4: vk::Bool32,
		arg_5: vk::AccelerationStructureNV,
		arg_6: vk::AccelerationStructureNV,
		arg_7: vk::Buffer,
		arg_8: vk::DeviceSize,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::AccelerationStructureInfoNV<'_>,
					) && arg_2 == vk::Buffer::from_raw(305398272_u64 as _)
					&& arg_3 == 305398528_u64 as vk::DeviceSize
					&& arg_4 == 305398784_u64 as vk::Bool32
					&& arg_5 == vk::AccelerationStructureNV::from_raw(305399040_u64 as _)
					&& arg_6 == vk::AccelerationStructureNV::from_raw(305399296_u64 as _)
					&& arg_7 == vk::Buffer::from_raw(305399552_u64 as _)
					&& arg_8 == 305399808_u64 as vk::DeviceSize),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdBuildAccelerationStructureNV = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkCmdBuildAccelerationStructureNV,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdBuildAccelerationStructureNV", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_build_acceleration_structure_nv(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::AccelerationStructureInfoNV<'_>,
			vk::Buffer::from_raw(305398272_u64 as _),
			305398528_u64 as vk::DeviceSize,
			305398784_u64 as vk::Bool32,
			vk::AccelerationStructureNV::from_raw(305399040_u64 as _),
			vk::AccelerationStructureNV::from_raw(305399296_u64 as _),
			vk::Buffer::from_raw(305399552_u64 as _),
			305399808_u64 as vk::DeviceSize,
		)
		.unwrap();
		vk::Device::cmd_build_acceleration_structure_nv(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::AccelerationStructureInfoNV<'_>,
			vk::Buffer::from_raw(305398272_u64 as _),
			305398528_u64 as vk::DeviceSize,
			305398784_u64 as vk::Bool32,
			vk::AccelerationStructureNV::from_raw(305399040_u64 as _),
			vk::AccelerationStructureNV::from_raw(305399296_u64 as _),
			vk::Buffer::from_raw(305399552_u64 as _),
			305399808_u64 as vk::DeviceSize,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn write_acceleration_structures_properties_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		u32,
		*const vk::AccelerationStructureKHR,
		vk::QueryType,
		usize,
		*mut std::ffi::c_void,
		usize,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::write_acceleration_structures_properties_khr;
	let _: Signature = vk::Device::write_acceleration_structures_properties_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::write_acceleration_structures_properties_khr(
				&fixture.device,
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::AccelerationStructureKHR>(),
				std::mem::zeroed::<vk::QueryType>(),
				std::mem::zeroed::<usize>(),
				std::mem::zeroed::<*mut std::ffi::c_void>(),
				std::mem::zeroed::<usize>()
			),
			Err(CallError::MissingCommand(
				"vkWriteAccelerationStructuresPropertiesKHR"
			))
		));
		assert!(matches!(
			fixture.device.write_acceleration_structures_properties_khr(
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::AccelerationStructureKHR>(),
				std::mem::zeroed::<vk::QueryType>(),
				std::mem::zeroed::<usize>(),
				std::mem::zeroed::<*mut std::ffi::c_void>(),
				std::mem::zeroed::<usize>()
			),
			Err(CallError::MissingCommand(
				"vkWriteAccelerationStructuresPropertiesKHR"
			))
		));
	}
}

#[test]
fn write_acceleration_structures_properties_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: u32,
		arg_2: *const vk::AccelerationStructureKHR,
		arg_3: vk::QueryType,
		arg_4: usize,
		arg_5: *mut std::ffi::c_void,
		arg_6: usize,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == Default::default()
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *const vk::AccelerationStructureKHR,
					) && arg_3 == vk::QueryType::from_raw(305398528_u64 as _)
					&& arg_4 == Default::default()
					&& std::ptr::eq(
						arg_5,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305399040),
					) && arg_6 == Default::default()),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkWriteAccelerationStructuresPropertiesKHR = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkWriteAccelerationStructuresPropertiesKHR,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkWriteAccelerationStructuresPropertiesKHR", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::write_acceleration_structures_properties_khr(
					&fixture.device,
					Default::default(),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AccelerationStructureKHR,
					vk::QueryType::from_raw(305398528_u64 as _),
					Default::default(),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305399040),
					Default::default()
				),
				expected
			);
			assert_eq!(
				vk::Device::write_acceleration_structures_properties_khr(
					&fixture.device,
					Default::default(),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AccelerationStructureKHR,
					vk::QueryType::from_raw(305398528_u64 as _),
					Default::default(),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305399040),
					Default::default()
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_trace_rays_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		*const vk::StridedDeviceAddressRegionKHR,
		*const vk::StridedDeviceAddressRegionKHR,
		*const vk::StridedDeviceAddressRegionKHR,
		*const vk::StridedDeviceAddressRegionKHR,
		u32,
		u32,
		u32,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_trace_rays_khr;
	let _: Signature = vk::Device::cmd_trace_rays_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_trace_rays_khr(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::StridedDeviceAddressRegionKHR>(),
				std::mem::zeroed::<*const vk::StridedDeviceAddressRegionKHR>(),
				std::mem::zeroed::<*const vk::StridedDeviceAddressRegionKHR>(),
				std::mem::zeroed::<*const vk::StridedDeviceAddressRegionKHR>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>()
			),
			Err(CallError::MissingCommand("vkCmdTraceRaysKHR"))
		));
		assert!(matches!(
			fixture.device.cmd_trace_rays_khr(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::StridedDeviceAddressRegionKHR>(),
				std::mem::zeroed::<*const vk::StridedDeviceAddressRegionKHR>(),
				std::mem::zeroed::<*const vk::StridedDeviceAddressRegionKHR>(),
				std::mem::zeroed::<*const vk::StridedDeviceAddressRegionKHR>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>()
			),
			Err(CallError::MissingCommand("vkCmdTraceRaysKHR"))
		));
	}
}

#[test]
fn cmd_trace_rays_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }

	#[allow(clippy::too_many_arguments)]
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: *const vk::StridedDeviceAddressRegionKHR,
		arg_2: *const vk::StridedDeviceAddressRegionKHR,
		arg_3: *const vk::StridedDeviceAddressRegionKHR,
		arg_4: *const vk::StridedDeviceAddressRegionKHR,
		arg_5: u32,
		arg_6: u32,
		arg_7: u32,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::StridedDeviceAddressRegionKHR,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::StridedDeviceAddressRegionKHR,
				) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *const vk::StridedDeviceAddressRegionKHR,
				) && std::ptr::eq(
					arg_4,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784)
						as *const vk::StridedDeviceAddressRegionKHR,
				) && arg_5 == Default::default()
					&& arg_6 == Default::default()
					&& arg_7 == Default::default()),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdTraceRaysKHR = Some(mock);
		let erased = std::mem::transmute::<vk::PFN_vkCmdTraceRaysKHR, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdTraceRaysKHR", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_trace_rays_khr(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::StridedDeviceAddressRegionKHR,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::StridedDeviceAddressRegionKHR,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
				as *const vk::StridedDeviceAddressRegionKHR,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784)
				as *const vk::StridedDeviceAddressRegionKHR,
			Default::default(),
			Default::default(),
			Default::default(),
		)
		.unwrap();
		vk::Device::cmd_trace_rays_khr(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::StridedDeviceAddressRegionKHR,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::StridedDeviceAddressRegionKHR,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
				as *const vk::StridedDeviceAddressRegionKHR,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784)
				as *const vk::StridedDeviceAddressRegionKHR,
			Default::default(),
			Default::default(),
			Default::default(),
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_trace_rays_nv_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		vk::Buffer,
		vk::DeviceSize,
		vk::Buffer,
		vk::DeviceSize,
		vk::DeviceSize,
		vk::Buffer,
		vk::DeviceSize,
		vk::DeviceSize,
		vk::Buffer,
		vk::DeviceSize,
		vk::DeviceSize,
		u32,
		u32,
		u32,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_trace_rays_nv;
	let _: Signature = vk::Device::cmd_trace_rays_nv;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_trace_rays_nv(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::Buffer>(),
				std::mem::zeroed::<vk::DeviceSize>(),
				std::mem::zeroed::<vk::Buffer>(),
				std::mem::zeroed::<vk::DeviceSize>(),
				std::mem::zeroed::<vk::DeviceSize>(),
				std::mem::zeroed::<vk::Buffer>(),
				std::mem::zeroed::<vk::DeviceSize>(),
				std::mem::zeroed::<vk::DeviceSize>(),
				std::mem::zeroed::<vk::Buffer>(),
				std::mem::zeroed::<vk::DeviceSize>(),
				std::mem::zeroed::<vk::DeviceSize>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>()
			),
			Err(CallError::MissingCommand("vkCmdTraceRaysNV"))
		));
		assert!(matches!(
			fixture.device.cmd_trace_rays_nv(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::Buffer>(),
				std::mem::zeroed::<vk::DeviceSize>(),
				std::mem::zeroed::<vk::Buffer>(),
				std::mem::zeroed::<vk::DeviceSize>(),
				std::mem::zeroed::<vk::DeviceSize>(),
				std::mem::zeroed::<vk::Buffer>(),
				std::mem::zeroed::<vk::DeviceSize>(),
				std::mem::zeroed::<vk::DeviceSize>(),
				std::mem::zeroed::<vk::Buffer>(),
				std::mem::zeroed::<vk::DeviceSize>(),
				std::mem::zeroed::<vk::DeviceSize>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>()
			),
			Err(CallError::MissingCommand("vkCmdTraceRaysNV"))
		));
	}
}

#[test]
fn cmd_trace_rays_nv_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }

	#[allow(clippy::too_many_arguments)]
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: vk::Buffer,
		arg_2: vk::DeviceSize,
		arg_3: vk::Buffer,
		arg_4: vk::DeviceSize,
		arg_5: vk::DeviceSize,
		arg_6: vk::Buffer,
		arg_7: vk::DeviceSize,
		arg_8: vk::DeviceSize,
		arg_9: vk::Buffer,
		arg_10: vk::DeviceSize,
		arg_11: vk::DeviceSize,
		arg_12: u32,
		arg_13: u32,
		arg_14: u32,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == vk::Buffer::from_raw(305398016_u64 as _)
					&& arg_2 == 305398272_u64 as vk::DeviceSize
					&& arg_3 == vk::Buffer::from_raw(305398528_u64 as _)
					&& arg_4 == 305398784_u64 as vk::DeviceSize
					&& arg_5 == 305399040_u64 as vk::DeviceSize
					&& arg_6 == vk::Buffer::from_raw(305399296_u64 as _)
					&& arg_7 == 305399552_u64 as vk::DeviceSize
					&& arg_8 == 305399808_u64 as vk::DeviceSize
					&& arg_9 == vk::Buffer::from_raw(305400064_u64 as _)
					&& arg_10 == 305400320_u64 as vk::DeviceSize
					&& arg_11 == 305400576_u64 as vk::DeviceSize
					&& arg_12 == Default::default()
					&& arg_13 == Default::default()
					&& arg_14 == Default::default()),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdTraceRaysNV = Some(mock);
		let erased = std::mem::transmute::<vk::PFN_vkCmdTraceRaysNV, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdTraceRaysNV", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_trace_rays_nv(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::Buffer::from_raw(305398016_u64 as _),
			305398272_u64 as vk::DeviceSize,
			vk::Buffer::from_raw(305398528_u64 as _),
			305398784_u64 as vk::DeviceSize,
			305399040_u64 as vk::DeviceSize,
			vk::Buffer::from_raw(305399296_u64 as _),
			305399552_u64 as vk::DeviceSize,
			305399808_u64 as vk::DeviceSize,
			vk::Buffer::from_raw(305400064_u64 as _),
			305400320_u64 as vk::DeviceSize,
			305400576_u64 as vk::DeviceSize,
			Default::default(),
			Default::default(),
			Default::default(),
		)
		.unwrap();
		vk::Device::cmd_trace_rays_nv(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::Buffer::from_raw(305398016_u64 as _),
			305398272_u64 as vk::DeviceSize,
			vk::Buffer::from_raw(305398528_u64 as _),
			305398784_u64 as vk::DeviceSize,
			305399040_u64 as vk::DeviceSize,
			vk::Buffer::from_raw(305399296_u64 as _),
			305399552_u64 as vk::DeviceSize,
			305399808_u64 as vk::DeviceSize,
			vk::Buffer::from_raw(305400064_u64 as _),
			305400320_u64 as vk::DeviceSize,
			305400576_u64 as vk::DeviceSize,
			Default::default(),
			Default::default(),
			Default::default(),
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_ray_tracing_shader_group_handles_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::Pipeline,
		u32,
		u32,
		usize,
		*mut std::ffi::c_void,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_ray_tracing_shader_group_handles_khr;
	let _: Signature = vk::Device::get_ray_tracing_shader_group_handles_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_ray_tracing_shader_group_handles_khr(
				&fixture.device,
				std::mem::zeroed::<vk::Pipeline>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<usize>(),
				std::mem::zeroed::<*mut std::ffi::c_void>()
			),
			Err(CallError::MissingCommand(
				"vkGetRayTracingShaderGroupHandlesKHR"
			))
		));
		assert!(matches!(
			fixture.device.get_ray_tracing_shader_group_handles_khr(
				std::mem::zeroed::<vk::Pipeline>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<usize>(),
				std::mem::zeroed::<*mut std::ffi::c_void>()
			),
			Err(CallError::MissingCommand(
				"vkGetRayTracingShaderGroupHandlesKHR"
			))
		));
	}
}

#[test]
fn get_ray_tracing_shader_group_handles_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::Pipeline,
		arg_2: u32,
		arg_3: u32,
		arg_4: usize,
		arg_5: *mut std::ffi::c_void,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::Pipeline::from_raw(305398016_u64 as _)
					&& arg_2 == Default::default()
					&& arg_3 == Default::default()
					&& arg_4 == Default::default()
					&& std::ptr::eq(
						arg_5,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305399040),
					)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetRayTracingShaderGroupHandlesKHR = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetRayTracingShaderGroupHandlesKHR,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkGetRayTracingShaderGroupHandlesKHR", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_ray_tracing_shader_group_handles_khr(
					&fixture.device,
					vk::Pipeline::from_raw(305398016_u64 as _),
					Default::default(),
					Default::default(),
					Default::default(),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305399040)
				),
				expected
			);
			assert_eq!(
				vk::Device::get_ray_tracing_shader_group_handles_khr(
					&fixture.device,
					vk::Pipeline::from_raw(305398016_u64 as _),
					Default::default(),
					Default::default(),
					Default::default(),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305399040)
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_ray_tracing_shader_group_handles_nv_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::Pipeline,
		u32,
		u32,
		usize,
		*mut std::ffi::c_void,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_ray_tracing_shader_group_handles_nv;
	let _: Signature = vk::Device::get_ray_tracing_shader_group_handles_nv;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_ray_tracing_shader_group_handles_nv(
				&fixture.device,
				std::mem::zeroed::<vk::Pipeline>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<usize>(),
				std::mem::zeroed::<*mut std::ffi::c_void>()
			),
			Err(CallError::MissingCommand(
				"vkGetRayTracingShaderGroupHandlesNV"
			))
		));
		assert!(matches!(
			fixture.device.get_ray_tracing_shader_group_handles_nv(
				std::mem::zeroed::<vk::Pipeline>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<usize>(),
				std::mem::zeroed::<*mut std::ffi::c_void>()
			),
			Err(CallError::MissingCommand(
				"vkGetRayTracingShaderGroupHandlesNV"
			))
		));
	}
}

#[test]
fn get_ray_tracing_shader_group_handles_nv_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::Pipeline,
		arg_2: u32,
		arg_3: u32,
		arg_4: usize,
		arg_5: *mut std::ffi::c_void,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::Pipeline::from_raw(305398016_u64 as _)
					&& arg_2 == Default::default()
					&& arg_3 == Default::default()
					&& arg_4 == Default::default()
					&& std::ptr::eq(
						arg_5,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305399040),
					)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetRayTracingShaderGroupHandlesNV = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetRayTracingShaderGroupHandlesNV,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkGetRayTracingShaderGroupHandlesNV", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_ray_tracing_shader_group_handles_nv(
					&fixture.device,
					vk::Pipeline::from_raw(305398016_u64 as _),
					Default::default(),
					Default::default(),
					Default::default(),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305399040)
				),
				expected
			);
			assert_eq!(
				vk::Device::get_ray_tracing_shader_group_handles_nv(
					&fixture.device,
					vk::Pipeline::from_raw(305398016_u64 as _),
					Default::default(),
					Default::default(),
					Default::default(),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305399040)
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_ray_tracing_capture_replay_shader_group_handles_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::Pipeline,
		u32,
		u32,
		usize,
		*mut std::ffi::c_void,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_ray_tracing_capture_replay_shader_group_handles_khr;
	let _: Signature = vk::Device::get_ray_tracing_capture_replay_shader_group_handles_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_ray_tracing_capture_replay_shader_group_handles_khr(
				&fixture.device,
				std::mem::zeroed::<vk::Pipeline>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<usize>(),
				std::mem::zeroed::<*mut std::ffi::c_void>()
			),
			Err(CallError::MissingCommand(
				"vkGetRayTracingCaptureReplayShaderGroupHandlesKHR"
			))
		));
		assert!(matches!(
			fixture
				.device
				.get_ray_tracing_capture_replay_shader_group_handles_khr(
					std::mem::zeroed::<vk::Pipeline>(),
					std::mem::zeroed::<u32>(),
					std::mem::zeroed::<u32>(),
					std::mem::zeroed::<usize>(),
					std::mem::zeroed::<*mut std::ffi::c_void>()
				),
			Err(CallError::MissingCommand(
				"vkGetRayTracingCaptureReplayShaderGroupHandlesKHR"
			))
		));
	}
}

#[test]
fn get_ray_tracing_capture_replay_shader_group_handles_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::Pipeline,
		arg_2: u32,
		arg_3: u32,
		arg_4: usize,
		arg_5: *mut std::ffi::c_void,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::Pipeline::from_raw(305398016_u64 as _)
					&& arg_2 == Default::default()
					&& arg_3 == Default::default()
					&& arg_4 == Default::default()
					&& std::ptr::eq(
						arg_5,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305399040),
					)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture =
			Fixture::new_with_command(c"vkGetRayTracingCaptureReplayShaderGroupHandlesKHR", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_ray_tracing_capture_replay_shader_group_handles_khr(
					&fixture.device,
					vk::Pipeline::from_raw(305398016_u64 as _),
					Default::default(),
					Default::default(),
					Default::default(),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305399040)
				),
				expected
			);
			assert_eq!(
				vk::Device::get_ray_tracing_capture_replay_shader_group_handles_khr(
					&fixture.device,
					vk::Pipeline::from_raw(305398016_u64 as _),
					Default::default(),
					Default::default(),
					Default::default(),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305399040)
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_acceleration_structure_handle_nv_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::AccelerationStructureNV,
		usize,
		*mut std::ffi::c_void,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_acceleration_structure_handle_nv;
	let _: Signature = vk::Device::get_acceleration_structure_handle_nv;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_acceleration_structure_handle_nv(
				&fixture.device,
				std::mem::zeroed::<vk::AccelerationStructureNV>(),
				std::mem::zeroed::<usize>(),
				std::mem::zeroed::<*mut std::ffi::c_void>()
			),
			Err(CallError::MissingCommand(
				"vkGetAccelerationStructureHandleNV"
			))
		));
		assert!(matches!(
			fixture.device.get_acceleration_structure_handle_nv(
				std::mem::zeroed::<vk::AccelerationStructureNV>(),
				std::mem::zeroed::<usize>(),
				std::mem::zeroed::<*mut std::ffi::c_void>()
			),
			Err(CallError::MissingCommand(
				"vkGetAccelerationStructureHandleNV"
			))
		));
	}
}

#[test]
fn get_acceleration_structure_handle_nv_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::AccelerationStructureNV,
		arg_2: usize,
		arg_3: *mut std::ffi::c_void,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::AccelerationStructureNV::from_raw(305398016_u64 as _)
					&& arg_2 == Default::default()
					&& std::ptr::eq(
						arg_3,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528),
					)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetAccelerationStructureHandleNV = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetAccelerationStructureHandleNV,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkGetAccelerationStructureHandleNV", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_acceleration_structure_handle_nv(
					&fixture.device,
					vk::AccelerationStructureNV::from_raw(305398016_u64 as _),
					Default::default(),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
				),
				expected
			);
			assert_eq!(
				vk::Device::get_acceleration_structure_handle_nv(
					&fixture.device,
					vk::AccelerationStructureNV::from_raw(305398016_u64 as _),
					Default::default(),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn create_ray_tracing_pipelines_nv_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::PipelineCache,
		u32,
		*const vk::RayTracingPipelineCreateInfoNV<'_>,
		*const vk::AllocationCallbacks,
		*mut vk::Pipeline,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::create_ray_tracing_pipelines_nv;
	let _: Signature = vk::Device::create_ray_tracing_pipelines_nv;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::create_ray_tracing_pipelines_nv(
				&fixture.device,
				std::mem::zeroed::<vk::PipelineCache>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::RayTracingPipelineCreateInfoNV<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::Pipeline>()
			),
			Err(CallError::MissingCommand("vkCreateRayTracingPipelinesNV"))
		));
		assert!(matches!(
			fixture.device.create_ray_tracing_pipelines_nv(
				std::mem::zeroed::<vk::PipelineCache>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::RayTracingPipelineCreateInfoNV<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::Pipeline>()
			),
			Err(CallError::MissingCommand("vkCreateRayTracingPipelinesNV"))
		));
	}
}

#[test]
fn create_ray_tracing_pipelines_nv_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::PipelineCache,
		arg_2: u32,
		arg_3: *const vk::RayTracingPipelineCreateInfoNV<'_>,
		arg_4: *const vk::AllocationCallbacks,
		arg_5: *mut vk::Pipeline,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::PipelineCache::from_raw(305398016_u64 as _)
					&& arg_2 == Default::default()
					&& std::ptr::eq(
						arg_3,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
							as *const vk::RayTracingPipelineCreateInfoNV<'_>,
					) && std::ptr::eq(
					arg_4,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784)
						as *const vk::AllocationCallbacks,
				) && std::ptr::eq(
					arg_5,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305399040) as *mut vk::Pipeline,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCreateRayTracingPipelinesNV = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCreateRayTracingPipelinesNV, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCreateRayTracingPipelinesNV", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::create_ray_tracing_pipelines_nv(
					&fixture.device,
					vk::PipelineCache::from_raw(305398016_u64 as _),
					Default::default(),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *const vk::RayTracingPipelineCreateInfoNV<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305399040) as *mut vk::Pipeline
				),
				expected
			);
			assert_eq!(
				vk::Device::create_ray_tracing_pipelines_nv(
					&fixture.device,
					vk::PipelineCache::from_raw(305398016_u64 as _),
					Default::default(),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *const vk::RayTracingPipelineCreateInfoNV<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305399040) as *mut vk::Pipeline
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn create_ray_tracing_pipelines_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::DeferredOperationKHR,
		vk::PipelineCache,
		u32,
		*const vk::RayTracingPipelineCreateInfoKHR<'_>,
		*const vk::AllocationCallbacks,
		*mut vk::Pipeline,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::create_ray_tracing_pipelines_khr;
	let _: Signature = vk::Device::create_ray_tracing_pipelines_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::create_ray_tracing_pipelines_khr(
				&fixture.device,
				std::mem::zeroed::<vk::DeferredOperationKHR>(),
				std::mem::zeroed::<vk::PipelineCache>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::RayTracingPipelineCreateInfoKHR<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::Pipeline>()
			),
			Err(CallError::MissingCommand("vkCreateRayTracingPipelinesKHR"))
		));
		assert!(matches!(
			fixture.device.create_ray_tracing_pipelines_khr(
				std::mem::zeroed::<vk::DeferredOperationKHR>(),
				std::mem::zeroed::<vk::PipelineCache>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::RayTracingPipelineCreateInfoKHR<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::Pipeline>()
			),
			Err(CallError::MissingCommand("vkCreateRayTracingPipelinesKHR"))
		));
	}
}

#[test]
fn create_ray_tracing_pipelines_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::DeferredOperationKHR,
		arg_2: vk::PipelineCache,
		arg_3: u32,
		arg_4: *const vk::RayTracingPipelineCreateInfoKHR<'_>,
		arg_5: *const vk::AllocationCallbacks,
		arg_6: *mut vk::Pipeline,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::DeferredOperationKHR::from_raw(305398016_u64 as _)
					&& arg_2 == vk::PipelineCache::from_raw(305398272_u64 as _)
					&& arg_3 == Default::default()
					&& std::ptr::eq(
						arg_4,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784)
							as *const vk::RayTracingPipelineCreateInfoKHR<'_>,
					) && std::ptr::eq(
					arg_5,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305399040)
						as *const vk::AllocationCallbacks,
				) && std::ptr::eq(
					arg_6,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305399296) as *mut vk::Pipeline,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCreateRayTracingPipelinesKHR = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCreateRayTracingPipelinesKHR, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCreateRayTracingPipelinesKHR", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::create_ray_tracing_pipelines_khr(
					&fixture.device,
					vk::DeferredOperationKHR::from_raw(305398016_u64 as _),
					vk::PipelineCache::from_raw(305398272_u64 as _),
					Default::default(),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784)
						as *const vk::RayTracingPipelineCreateInfoKHR<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305399040)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305399296) as *mut vk::Pipeline
				),
				expected
			);
			assert_eq!(
				vk::Device::create_ray_tracing_pipelines_khr(
					&fixture.device,
					vk::DeferredOperationKHR::from_raw(305398016_u64 as _),
					vk::PipelineCache::from_raw(305398272_u64 as _),
					Default::default(),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784)
						as *const vk::RayTracingPipelineCreateInfoKHR<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305399040)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305399296) as *mut vk::Pipeline
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_physical_device_cooperative_matrix_properties_nv_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		vk::PhysicalDevice,
		*mut u32,
		*mut vk::CooperativeMatrixPropertiesNV<'_>,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_physical_device_cooperative_matrix_properties_nv;
	let _: Signature = vk::Instance::get_physical_device_cooperative_matrix_properties_nv;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_physical_device_cooperative_matrix_properties_nv(
				&fixture.instance,
				std::mem::zeroed::<vk::PhysicalDevice>(),
				std::mem::zeroed::<*mut u32>(),
				std::mem::zeroed::<*mut vk::CooperativeMatrixPropertiesNV<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceCooperativeMatrixPropertiesNV"
			))
		));
		assert!(matches!(
			fixture
				.instance
				.get_physical_device_cooperative_matrix_properties_nv(
					std::mem::zeroed::<vk::PhysicalDevice>(),
					std::mem::zeroed::<*mut u32>(),
					std::mem::zeroed::<*mut vk::CooperativeMatrixPropertiesNV<'_>>()
				),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceCooperativeMatrixPropertiesNV"
			))
		));
	}
}

#[test]
fn get_physical_device_cooperative_matrix_properties_nv_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::PhysicalDevice,
		arg_1: *mut u32,
		arg_2: *mut vk::CooperativeMatrixPropertiesNV<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::PhysicalDevice::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016) as *mut u32,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::CooperativeMatrixPropertiesNV<'_>,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture =
			Fixture::new_with_command(c"vkGetPhysicalDeviceCooperativeMatrixPropertiesNV", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_physical_device_cooperative_matrix_properties_nv(
					&fixture.instance,
					vk::PhysicalDevice::from_raw(305397760_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016) as *mut u32,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::CooperativeMatrixPropertiesNV<'_>
				),
				expected
			);
			assert_eq!(
				vk::Instance::get_physical_device_cooperative_matrix_properties_nv(
					&fixture.instance,
					vk::PhysicalDevice::from_raw(305397760_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016) as *mut u32,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::CooperativeMatrixPropertiesNV<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_trace_rays_indirect_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		*const vk::StridedDeviceAddressRegionKHR,
		*const vk::StridedDeviceAddressRegionKHR,
		*const vk::StridedDeviceAddressRegionKHR,
		*const vk::StridedDeviceAddressRegionKHR,
		vk::DeviceAddress,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_trace_rays_indirect_khr;
	let _: Signature = vk::Device::cmd_trace_rays_indirect_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_trace_rays_indirect_khr(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::StridedDeviceAddressRegionKHR>(),
				std::mem::zeroed::<*const vk::StridedDeviceAddressRegionKHR>(),
				std::mem::zeroed::<*const vk::StridedDeviceAddressRegionKHR>(),
				std::mem::zeroed::<*const vk::StridedDeviceAddressRegionKHR>(),
				std::mem::zeroed::<vk::DeviceAddress>()
			),
			Err(CallError::MissingCommand("vkCmdTraceRaysIndirectKHR"))
		));
		assert!(matches!(
			fixture.device.cmd_trace_rays_indirect_khr(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::StridedDeviceAddressRegionKHR>(),
				std::mem::zeroed::<*const vk::StridedDeviceAddressRegionKHR>(),
				std::mem::zeroed::<*const vk::StridedDeviceAddressRegionKHR>(),
				std::mem::zeroed::<*const vk::StridedDeviceAddressRegionKHR>(),
				std::mem::zeroed::<vk::DeviceAddress>()
			),
			Err(CallError::MissingCommand("vkCmdTraceRaysIndirectKHR"))
		));
	}
}

#[test]
fn cmd_trace_rays_indirect_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: *const vk::StridedDeviceAddressRegionKHR,
		arg_2: *const vk::StridedDeviceAddressRegionKHR,
		arg_3: *const vk::StridedDeviceAddressRegionKHR,
		arg_4: *const vk::StridedDeviceAddressRegionKHR,
		arg_5: vk::DeviceAddress,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::StridedDeviceAddressRegionKHR,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::StridedDeviceAddressRegionKHR,
				) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *const vk::StridedDeviceAddressRegionKHR,
				) && std::ptr::eq(
					arg_4,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784)
						as *const vk::StridedDeviceAddressRegionKHR,
				) && arg_5 == 305399040_u64 as vk::DeviceAddress),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdTraceRaysIndirectKHR = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdTraceRaysIndirectKHR, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdTraceRaysIndirectKHR", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_trace_rays_indirect_khr(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::StridedDeviceAddressRegionKHR,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::StridedDeviceAddressRegionKHR,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
				as *const vk::StridedDeviceAddressRegionKHR,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784)
				as *const vk::StridedDeviceAddressRegionKHR,
			305399040_u64 as vk::DeviceAddress,
		)
		.unwrap();
		vk::Device::cmd_trace_rays_indirect_khr(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::StridedDeviceAddressRegionKHR,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::StridedDeviceAddressRegionKHR,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
				as *const vk::StridedDeviceAddressRegionKHR,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784)
				as *const vk::StridedDeviceAddressRegionKHR,
			305399040_u64 as vk::DeviceAddress,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_trace_rays_indirect2_khr_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, vk::CommandBuffer, vk::DeviceAddress) -> Result<(), CallError>;
	let _: Signature = vk::cmd_trace_rays_indirect2_khr;
	let _: Signature = vk::Device::cmd_trace_rays_indirect2_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_trace_rays_indirect2_khr(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::DeviceAddress>()
			),
			Err(CallError::MissingCommand("vkCmdTraceRaysIndirect2KHR"))
		));
		assert!(matches!(
			fixture.device.cmd_trace_rays_indirect2_khr(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::DeviceAddress>()
			),
			Err(CallError::MissingCommand("vkCmdTraceRaysIndirect2KHR"))
		));
	}
}

#[test]
fn cmd_trace_rays_indirect2_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::CommandBuffer, arg_1: vk::DeviceAddress) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == 305398016_u64 as vk::DeviceAddress),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdTraceRaysIndirect2KHR = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdTraceRaysIndirect2KHR, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdTraceRaysIndirect2KHR", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_trace_rays_indirect2_khr(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			305398016_u64 as vk::DeviceAddress,
		)
		.unwrap();
		vk::Device::cmd_trace_rays_indirect2_khr(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			305398016_u64 as vk::DeviceAddress,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_cluster_acceleration_structure_build_sizes_nv_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::ClusterAccelerationStructureInputInfoNV<'_>,
		*mut vk::AccelerationStructureBuildSizesInfoKHR<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::get_cluster_acceleration_structure_build_sizes_nv;
	let _: Signature = vk::Device::get_cluster_acceleration_structure_build_sizes_nv;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_cluster_acceleration_structure_build_sizes_nv(
				&fixture.device,
				std::mem::zeroed::<*const vk::ClusterAccelerationStructureInputInfoNV<'_>>(),
				std::mem::zeroed::<*mut vk::AccelerationStructureBuildSizesInfoKHR<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetClusterAccelerationStructureBuildSizesNV"
			))
		));
		assert!(matches!(
			fixture
				.device
				.get_cluster_acceleration_structure_build_sizes_nv(
					std::mem::zeroed::<*const vk::ClusterAccelerationStructureInputInfoNV<'_>>(),
					std::mem::zeroed::<*mut vk::AccelerationStructureBuildSizesInfoKHR<'_>>()
				),
			Err(CallError::MissingCommand(
				"vkGetClusterAccelerationStructureBuildSizesNV"
			))
		));
	}
}

#[test]
fn get_cluster_acceleration_structure_build_sizes_nv_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::ClusterAccelerationStructureInputInfoNV<'_>,
		arg_2: *mut vk::AccelerationStructureBuildSizesInfoKHR<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::ClusterAccelerationStructureInputInfoNV<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::AccelerationStructureBuildSizesInfoKHR<'_>,
				)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetClusterAccelerationStructureBuildSizesNV = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetClusterAccelerationStructureBuildSizesNV,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture =
			Fixture::new_with_command(c"vkGetClusterAccelerationStructureBuildSizesNV", erased);
		let resolutions = Fixture::query_count();
		vk::get_cluster_acceleration_structure_build_sizes_nv(
			&fixture.device,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::ClusterAccelerationStructureInputInfoNV<'_>,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *mut vk::AccelerationStructureBuildSizesInfoKHR<'_>,
		)
		.unwrap();
		vk::Device::get_cluster_acceleration_structure_build_sizes_nv(
			&fixture.device,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::ClusterAccelerationStructureInputInfoNV<'_>,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *mut vk::AccelerationStructureBuildSizesInfoKHR<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_build_cluster_acceleration_structure_indirect_nv_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		*const vk::ClusterAccelerationStructureCommandsInfoNV<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_build_cluster_acceleration_structure_indirect_nv;
	let _: Signature = vk::Device::cmd_build_cluster_acceleration_structure_indirect_nv;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_build_cluster_acceleration_structure_indirect_nv(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::ClusterAccelerationStructureCommandsInfoNV<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkCmdBuildClusterAccelerationStructureIndirectNV"
			))
		));
		assert!(matches!(
			fixture
				.device
				.cmd_build_cluster_acceleration_structure_indirect_nv(
					std::mem::zeroed::<vk::CommandBuffer>(),
					std::mem::zeroed::<*const vk::ClusterAccelerationStructureCommandsInfoNV<'_>>()
				),
			Err(CallError::MissingCommand(
				"vkCmdBuildClusterAccelerationStructureIndirectNV"
			))
		));
	}
}

#[test]
fn cmd_build_cluster_acceleration_structure_indirect_nv_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: *const vk::ClusterAccelerationStructureCommandsInfoNV<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::ClusterAccelerationStructureCommandsInfoNV<'_>,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdBuildClusterAccelerationStructureIndirectNV = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkCmdBuildClusterAccelerationStructureIndirectNV,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture =
			Fixture::new_with_command(c"vkCmdBuildClusterAccelerationStructureIndirectNV", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_build_cluster_acceleration_structure_indirect_nv(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::ClusterAccelerationStructureCommandsInfoNV<'_>,
		)
		.unwrap();
		vk::Device::cmd_build_cluster_acceleration_structure_indirect_nv(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::ClusterAccelerationStructureCommandsInfoNV<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_device_acceleration_structure_compatibility_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::AccelerationStructureVersionInfoKHR<'_>,
		*mut vk::AccelerationStructureCompatibilityKHR,
	) -> Result<(), CallError>;
	let _: Signature = vk::get_device_acceleration_structure_compatibility_khr;
	let _: Signature = vk::Device::get_device_acceleration_structure_compatibility_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_device_acceleration_structure_compatibility_khr(
				&fixture.device,
				std::mem::zeroed::<*const vk::AccelerationStructureVersionInfoKHR<'_>>(),
				std::mem::zeroed::<*mut vk::AccelerationStructureCompatibilityKHR>()
			),
			Err(CallError::MissingCommand(
				"vkGetDeviceAccelerationStructureCompatibilityKHR"
			))
		));
		assert!(matches!(
			fixture
				.device
				.get_device_acceleration_structure_compatibility_khr(
					std::mem::zeroed::<*const vk::AccelerationStructureVersionInfoKHR<'_>>(),
					std::mem::zeroed::<*mut vk::AccelerationStructureCompatibilityKHR>()
				),
			Err(CallError::MissingCommand(
				"vkGetDeviceAccelerationStructureCompatibilityKHR"
			))
		));
	}
}

#[test]
fn get_device_acceleration_structure_compatibility_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::AccelerationStructureVersionInfoKHR<'_>,
		arg_2: *mut vk::AccelerationStructureCompatibilityKHR,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::AccelerationStructureVersionInfoKHR<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::AccelerationStructureCompatibilityKHR,
				)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetDeviceAccelerationStructureCompatibilityKHR = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetDeviceAccelerationStructureCompatibilityKHR,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture =
			Fixture::new_with_command(c"vkGetDeviceAccelerationStructureCompatibilityKHR", erased);
		let resolutions = Fixture::query_count();
		vk::get_device_acceleration_structure_compatibility_khr(
			&fixture.device,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::AccelerationStructureVersionInfoKHR<'_>,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *mut vk::AccelerationStructureCompatibilityKHR,
		)
		.unwrap();
		vk::Device::get_device_acceleration_structure_compatibility_khr(
			&fixture.device,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::AccelerationStructureVersionInfoKHR<'_>,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *mut vk::AccelerationStructureCompatibilityKHR,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_ray_tracing_shader_group_stack_size_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::Pipeline,
		u32,
		vk::ShaderGroupShaderKHR,
	) -> Result<vk::DeviceSize, CallError>;
	let _: Signature = vk::get_ray_tracing_shader_group_stack_size_khr;
	let _: Signature = vk::Device::get_ray_tracing_shader_group_stack_size_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_ray_tracing_shader_group_stack_size_khr(
				&fixture.device,
				std::mem::zeroed::<vk::Pipeline>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<vk::ShaderGroupShaderKHR>()
			),
			Err(CallError::MissingCommand(
				"vkGetRayTracingShaderGroupStackSizeKHR"
			))
		));
		assert!(matches!(
			fixture.device.get_ray_tracing_shader_group_stack_size_khr(
				std::mem::zeroed::<vk::Pipeline>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<vk::ShaderGroupShaderKHR>()
			),
			Err(CallError::MissingCommand(
				"vkGetRayTracingShaderGroupStackSizeKHR"
			))
		));
	}
}

#[test]
fn get_ray_tracing_shader_group_stack_size_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::Pipeline,
		arg_2: u32,
		arg_3: vk::ShaderGroupShaderKHR,
	) -> vk::DeviceSize {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::Pipeline::from_raw(305398016_u64 as _)
					&& arg_2 == Default::default()
					&& arg_3 == vk::ShaderGroupShaderKHR::from_raw(305398528_u64 as _)),
		);
		0xfedc_ba98_7654_3210_u64 as vk::DeviceSize
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetRayTracingShaderGroupStackSizeKHR = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetRayTracingShaderGroupStackSizeKHR,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkGetRayTracingShaderGroupStackSizeKHR", erased);
		let resolutions = Fixture::query_count();
		assert_eq!(
			vk::get_ray_tracing_shader_group_stack_size_khr(
				&fixture.device,
				vk::Pipeline::from_raw(305398016_u64 as _),
				Default::default(),
				vk::ShaderGroupShaderKHR::from_raw(305398528_u64 as _)
			)
			.unwrap(),
			0xfedc_ba98_7654_3210_u64 as vk::DeviceSize
		);
		assert_eq!(
			vk::Device::get_ray_tracing_shader_group_stack_size_khr(
				&fixture.device,
				vk::Pipeline::from_raw(305398016_u64 as _),
				Default::default(),
				vk::ShaderGroupShaderKHR::from_raw(305398528_u64 as _)
			)
			.unwrap(),
			0xfedc_ba98_7654_3210_u64 as vk::DeviceSize
		);
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_set_ray_tracing_pipeline_stack_size_khr_signature_and_missing_command() {
	type Signature = unsafe fn(&vk::Device, vk::CommandBuffer, u32) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_ray_tracing_pipeline_stack_size_khr;
	let _: Signature = vk::Device::cmd_set_ray_tracing_pipeline_stack_size_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_ray_tracing_pipeline_stack_size_khr(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>()
			),
			Err(CallError::MissingCommand(
				"vkCmdSetRayTracingPipelineStackSizeKHR"
			))
		));
		assert!(matches!(
			fixture.device.cmd_set_ray_tracing_pipeline_stack_size_khr(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>()
			),
			Err(CallError::MissingCommand(
				"vkCmdSetRayTracingPipelineStackSizeKHR"
			))
		));
	}
}

#[test]
fn cmd_set_ray_tracing_pipeline_stack_size_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::CommandBuffer, arg_1: u32) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == Default::default()),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdSetRayTracingPipelineStackSizeKHR = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkCmdSetRayTracingPipelineStackSizeKHR,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdSetRayTracingPipelineStackSizeKHR", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_set_ray_tracing_pipeline_stack_size_khr(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
		)
		.unwrap();
		vk::Device::cmd_set_ray_tracing_pipeline_stack_size_khr(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_image_view_handle_nvx_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, *const vk::ImageViewHandleInfoNVX<'_>) -> Result<u32, CallError>;
	let _: Signature = vk::get_image_view_handle_nvx;
	let _: Signature = vk::Device::get_image_view_handle_nvx;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_image_view_handle_nvx(
				&fixture.device,
				std::mem::zeroed::<*const vk::ImageViewHandleInfoNVX<'_>>()
			),
			Err(CallError::MissingCommand("vkGetImageViewHandleNVX"))
		));
		assert!(matches!(
			fixture
				.device
				.get_image_view_handle_nvx(std::mem::zeroed::<*const vk::ImageViewHandleInfoNVX<'_>>()),
			Err(CallError::MissingCommand("vkGetImageViewHandleNVX"))
		));
	}
}

#[test]
fn get_image_view_handle_nvx_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::ImageViewHandleInfoNVX<'_>,
	) -> u32 {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::ImageViewHandleInfoNVX<'_>,
					)),
		);
		0xfedc_ba98_7654_3210_u64 as u32
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetImageViewHandleNVX = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkGetImageViewHandleNVX, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkGetImageViewHandleNVX", erased);
		let resolutions = Fixture::query_count();
		assert_eq!(
			vk::get_image_view_handle_nvx(
				&fixture.device,
				std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
					as *const vk::ImageViewHandleInfoNVX<'_>
			)
			.unwrap(),
			0xfedc_ba98_7654_3210_u64 as u32
		);
		assert_eq!(
			vk::Device::get_image_view_handle_nvx(
				&fixture.device,
				std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
					as *const vk::ImageViewHandleInfoNVX<'_>
			)
			.unwrap(),
			0xfedc_ba98_7654_3210_u64 as u32
		);
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_image_view_handle64_nvx_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, *const vk::ImageViewHandleInfoNVX<'_>) -> Result<u64, CallError>;
	let _: Signature = vk::get_image_view_handle64_nvx;
	let _: Signature = vk::Device::get_image_view_handle64_nvx;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_image_view_handle64_nvx(
				&fixture.device,
				std::mem::zeroed::<*const vk::ImageViewHandleInfoNVX<'_>>()
			),
			Err(CallError::MissingCommand("vkGetImageViewHandle64NVX"))
		));
		assert!(matches!(
			fixture
				.device
				.get_image_view_handle64_nvx(std::mem::zeroed::<*const vk::ImageViewHandleInfoNVX<'_>>()),
			Err(CallError::MissingCommand("vkGetImageViewHandle64NVX"))
		));
	}
}

#[test]
fn get_image_view_handle64_nvx_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::ImageViewHandleInfoNVX<'_>,
	) -> u64 {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::ImageViewHandleInfoNVX<'_>,
					)),
		);
		0xfedc_ba98_7654_3210_u64
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetImageViewHandle64NVX = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkGetImageViewHandle64NVX, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkGetImageViewHandle64NVX", erased);
		let resolutions = Fixture::query_count();
		assert_eq!(
			vk::get_image_view_handle64_nvx(
				&fixture.device,
				std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
					as *const vk::ImageViewHandleInfoNVX<'_>
			)
			.unwrap(),
			0xfedc_ba98_7654_3210_u64
		);
		assert_eq!(
			vk::Device::get_image_view_handle64_nvx(
				&fixture.device,
				std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
					as *const vk::ImageViewHandleInfoNVX<'_>
			)
			.unwrap(),
			0xfedc_ba98_7654_3210_u64
		);
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_image_view_address_nvx_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::ImageView,
		*mut vk::ImageViewAddressPropertiesNVX<'_>,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_image_view_address_nvx;
	let _: Signature = vk::Device::get_image_view_address_nvx;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_image_view_address_nvx(
				&fixture.device,
				std::mem::zeroed::<vk::ImageView>(),
				std::mem::zeroed::<*mut vk::ImageViewAddressPropertiesNVX<'_>>()
			),
			Err(CallError::MissingCommand("vkGetImageViewAddressNVX"))
		));
		assert!(matches!(
			fixture.device.get_image_view_address_nvx(
				std::mem::zeroed::<vk::ImageView>(),
				std::mem::zeroed::<*mut vk::ImageViewAddressPropertiesNVX<'_>>()
			),
			Err(CallError::MissingCommand("vkGetImageViewAddressNVX"))
		));
	}
}

#[test]
fn get_image_view_address_nvx_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::ImageView,
		arg_2: *mut vk::ImageViewAddressPropertiesNVX<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::ImageView::from_raw(305398016_u64 as _)
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *mut vk::ImageViewAddressPropertiesNVX<'_>,
					)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetImageViewAddressNVX = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkGetImageViewAddressNVX, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkGetImageViewAddressNVX", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_image_view_address_nvx(
					&fixture.device,
					vk::ImageView::from_raw(305398016_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::ImageViewAddressPropertiesNVX<'_>
				),
				expected
			);
			assert_eq!(
				vk::Device::get_image_view_address_nvx(
					&fixture.device,
					vk::ImageView::from_raw(305398016_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::ImageViewAddressPropertiesNVX<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_device_combined_image_sampler_index_nvx_signature_and_missing_command() {
	type Signature = unsafe fn(&vk::Device, u64, u64) -> Result<u64, CallError>;
	let _: Signature = vk::get_device_combined_image_sampler_index_nvx;
	let _: Signature = vk::Device::get_device_combined_image_sampler_index_nvx;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_device_combined_image_sampler_index_nvx(
				&fixture.device,
				std::mem::zeroed::<u64>(),
				std::mem::zeroed::<u64>()
			),
			Err(CallError::MissingCommand(
				"vkGetDeviceCombinedImageSamplerIndexNVX"
			))
		));
		assert!(matches!(
			fixture.device.get_device_combined_image_sampler_index_nvx(
				std::mem::zeroed::<u64>(),
				std::mem::zeroed::<u64>()
			),
			Err(CallError::MissingCommand(
				"vkGetDeviceCombinedImageSamplerIndexNVX"
			))
		));
	}
}

#[test]
fn get_device_combined_image_sampler_index_nvx_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::DeviceHandle, arg_1: u64, arg_2: u64) -> u64 {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == Default::default()
					&& arg_2 == Default::default()),
		);
		0xfedc_ba98_7654_3210_u64
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetDeviceCombinedImageSamplerIndexNVX = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetDeviceCombinedImageSamplerIndexNVX,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkGetDeviceCombinedImageSamplerIndexNVX", erased);
		let resolutions = Fixture::query_count();
		assert_eq!(
			vk::get_device_combined_image_sampler_index_nvx(
				&fixture.device,
				Default::default(),
				Default::default()
			)
			.unwrap(),
			0xfedc_ba98_7654_3210_u64
		);
		assert_eq!(
			vk::Device::get_device_combined_image_sampler_index_nvx(
				&fixture.device,
				Default::default(),
				Default::default()
			)
			.unwrap(),
			0xfedc_ba98_7654_3210_u64
		);
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[cfg(feature = "platform-win32")]
#[test]
fn get_physical_device_surface_present_modes2_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		vk::PhysicalDevice,
		*const vk::PhysicalDeviceSurfaceInfo2KHR<'_>,
		*mut u32,
		*mut vk::PresentModeKHR,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_physical_device_surface_present_modes2_ext;
	let _: Signature = vk::Instance::get_physical_device_surface_present_modes2_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_physical_device_surface_present_modes2_ext(
				&fixture.instance,
				std::mem::zeroed::<vk::PhysicalDevice>(),
				std::mem::zeroed::<*const vk::PhysicalDeviceSurfaceInfo2KHR<'_>>(),
				std::mem::zeroed::<*mut u32>(),
				std::mem::zeroed::<*mut vk::PresentModeKHR>()
			),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceSurfacePresentModes2EXT"
			))
		));
		assert!(matches!(
			fixture
				.instance
				.get_physical_device_surface_present_modes2_ext(
					std::mem::zeroed::<vk::PhysicalDevice>(),
					std::mem::zeroed::<*const vk::PhysicalDeviceSurfaceInfo2KHR<'_>>(),
					std::mem::zeroed::<*mut u32>(),
					std::mem::zeroed::<*mut vk::PresentModeKHR>()
				),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceSurfacePresentModes2EXT"
			))
		));
	}
}

#[cfg(feature = "platform-win32")]
#[test]
fn get_physical_device_surface_present_modes2_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::PhysicalDevice,
		arg_1: *const vk::PhysicalDeviceSurfaceInfo2KHR<'_>,
		arg_2: *mut u32,
		arg_3: *mut vk::PresentModeKHR,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::PhysicalDevice::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::PhysicalDeviceSurfaceInfo2KHR<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut u32,
				) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::PresentModeKHR,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkGetPhysicalDeviceSurfacePresentModes2EXT", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_physical_device_surface_present_modes2_ext(
					&fixture.instance,
					vk::PhysicalDevice::from_raw(305397760_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::PhysicalDeviceSurfaceInfo2KHR<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut u32,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::PresentModeKHR
				),
				expected
			);
			assert_eq!(
				vk::Instance::get_physical_device_surface_present_modes2_ext(
					&fixture.instance,
					vk::PhysicalDevice::from_raw(305397760_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::PhysicalDeviceSurfaceInfo2KHR<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut u32,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::PresentModeKHR
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[cfg(feature = "platform-win32")]
#[test]
fn get_device_group_surface_present_modes2_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::PhysicalDeviceSurfaceInfo2KHR<'_>,
		*mut vk::DeviceGroupPresentModeFlagsKHR,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_device_group_surface_present_modes2_ext;
	let _: Signature = vk::Device::get_device_group_surface_present_modes2_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_device_group_surface_present_modes2_ext(
				&fixture.device,
				std::mem::zeroed::<*const vk::PhysicalDeviceSurfaceInfo2KHR<'_>>(),
				std::mem::zeroed::<*mut vk::DeviceGroupPresentModeFlagsKHR>()
			),
			Err(CallError::MissingCommand(
				"vkGetDeviceGroupSurfacePresentModes2EXT"
			))
		));
		assert!(matches!(
			fixture.device.get_device_group_surface_present_modes2_ext(
				std::mem::zeroed::<*const vk::PhysicalDeviceSurfaceInfo2KHR<'_>>(),
				std::mem::zeroed::<*mut vk::DeviceGroupPresentModeFlagsKHR>()
			),
			Err(CallError::MissingCommand(
				"vkGetDeviceGroupSurfacePresentModes2EXT"
			))
		));
	}
}

#[cfg(feature = "platform-win32")]
#[test]
fn get_device_group_surface_present_modes2_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::PhysicalDeviceSurfaceInfo2KHR<'_>,
		arg_2: *mut vk::DeviceGroupPresentModeFlagsKHR,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::PhysicalDeviceSurfaceInfo2KHR<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::DeviceGroupPresentModeFlagsKHR,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetDeviceGroupSurfacePresentModes2EXT = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetDeviceGroupSurfacePresentModes2EXT,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkGetDeviceGroupSurfacePresentModes2EXT", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_device_group_surface_present_modes2_ext(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::PhysicalDeviceSurfaceInfo2KHR<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::DeviceGroupPresentModeFlagsKHR
				),
				expected
			);
			assert_eq!(
				vk::Device::get_device_group_surface_present_modes2_ext(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::PhysicalDeviceSurfaceInfo2KHR<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::DeviceGroupPresentModeFlagsKHR
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[cfg(feature = "platform-win32")]
#[test]
fn acquire_full_screen_exclusive_mode_ext_signature_and_missing_command() {
	type Signature = unsafe fn(&vk::Device, vk::SwapchainKHR) -> Result<vk::Result, CallError>;
	let _: Signature = vk::acquire_full_screen_exclusive_mode_ext;
	let _: Signature = vk::Device::acquire_full_screen_exclusive_mode_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::acquire_full_screen_exclusive_mode_ext(
				&fixture.device,
				std::mem::zeroed::<vk::SwapchainKHR>()
			),
			Err(CallError::MissingCommand(
				"vkAcquireFullScreenExclusiveModeEXT"
			))
		));
		assert!(matches!(
			fixture
				.device
				.acquire_full_screen_exclusive_mode_ext(std::mem::zeroed::<vk::SwapchainKHR>()),
			Err(CallError::MissingCommand(
				"vkAcquireFullScreenExclusiveModeEXT"
			))
		));
	}
}

#[cfg(feature = "platform-win32")]
#[test]
fn acquire_full_screen_exclusive_mode_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::DeviceHandle, arg_1: vk::SwapchainKHR) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::SwapchainKHR::from_raw(305398016_u64 as _)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkAcquireFullScreenExclusiveModeEXT = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkAcquireFullScreenExclusiveModeEXT,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkAcquireFullScreenExclusiveModeEXT", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::acquire_full_screen_exclusive_mode_ext(
					&fixture.device,
					vk::SwapchainKHR::from_raw(305398016_u64 as _)
				),
				expected
			);
			assert_eq!(
				vk::Device::acquire_full_screen_exclusive_mode_ext(
					&fixture.device,
					vk::SwapchainKHR::from_raw(305398016_u64 as _)
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[cfg(feature = "platform-win32")]
#[test]
fn release_full_screen_exclusive_mode_ext_signature_and_missing_command() {
	type Signature = unsafe fn(&vk::Device, vk::SwapchainKHR) -> Result<vk::Result, CallError>;
	let _: Signature = vk::release_full_screen_exclusive_mode_ext;
	let _: Signature = vk::Device::release_full_screen_exclusive_mode_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::release_full_screen_exclusive_mode_ext(
				&fixture.device,
				std::mem::zeroed::<vk::SwapchainKHR>()
			),
			Err(CallError::MissingCommand(
				"vkReleaseFullScreenExclusiveModeEXT"
			))
		));
		assert!(matches!(
			fixture
				.device
				.release_full_screen_exclusive_mode_ext(std::mem::zeroed::<vk::SwapchainKHR>()),
			Err(CallError::MissingCommand(
				"vkReleaseFullScreenExclusiveModeEXT"
			))
		));
	}
}

#[cfg(feature = "platform-win32")]
#[test]
fn release_full_screen_exclusive_mode_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::DeviceHandle, arg_1: vk::SwapchainKHR) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::SwapchainKHR::from_raw(305398016_u64 as _)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkReleaseFullScreenExclusiveModeEXT = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkReleaseFullScreenExclusiveModeEXT,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkReleaseFullScreenExclusiveModeEXT", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::release_full_screen_exclusive_mode_ext(
					&fixture.device,
					vk::SwapchainKHR::from_raw(305398016_u64 as _)
				),
				expected
			);
			assert_eq!(
				vk::Device::release_full_screen_exclusive_mode_ext(
					&fixture.device,
					vk::SwapchainKHR::from_raw(305398016_u64 as _)
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn enumerate_physical_device_queue_family_performance_query_counters_khr_signature_and_missing_command()
 {
	type Signature = unsafe fn(
		&vk::Instance,
		vk::PhysicalDevice,
		u32,
		*mut u32,
		*mut vk::PerformanceCounterKHR<'_>,
		*mut vk::PerformanceCounterDescriptionKHR<'_>,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::enumerate_physical_device_queue_family_performance_query_counters_khr;
	let _: Signature =
		vk::Instance::enumerate_physical_device_queue_family_performance_query_counters_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::enumerate_physical_device_queue_family_performance_query_counters_khr(
				&fixture.instance,
				std::mem::zeroed::<vk::PhysicalDevice>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*mut u32>(),
				std::mem::zeroed::<*mut vk::PerformanceCounterKHR<'_>>(),
				std::mem::zeroed::<*mut vk::PerformanceCounterDescriptionKHR<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR"
			))
		));
		assert!(matches!(
			fixture
				.instance
				.enumerate_physical_device_queue_family_performance_query_counters_khr(
					std::mem::zeroed::<vk::PhysicalDevice>(),
					std::mem::zeroed::<u32>(),
					std::mem::zeroed::<*mut u32>(),
					std::mem::zeroed::<*mut vk::PerformanceCounterKHR<'_>>(),
					std::mem::zeroed::<*mut vk::PerformanceCounterDescriptionKHR<'_>>()
				),
			Err(CallError::MissingCommand(
				"vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR"
			))
		));
	}
}

#[test]
fn enumerate_physical_device_queue_family_performance_query_counters_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::PhysicalDevice,
		arg_1: u32,
		arg_2: *mut u32,
		arg_3: *mut vk::PerformanceCounterKHR<'_>,
		arg_4: *mut vk::PerformanceCounterDescriptionKHR<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::PhysicalDevice::from_raw(305397760_u64 as _)
					&& arg_1 == Default::default()
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut u32,
					) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::PerformanceCounterKHR<'_>,
				) && std::ptr::eq(
					arg_4,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784)
						as *mut vk::PerformanceCounterDescriptionKHR<'_>,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(
			c"vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR",
			erased,
		);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::enumerate_physical_device_queue_family_performance_query_counters_khr(
					&fixture.instance,
					vk::PhysicalDevice::from_raw(305397760_u64 as _),
					Default::default(),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut u32,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::PerformanceCounterKHR<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784)
						as *mut vk::PerformanceCounterDescriptionKHR<'_>
				),
				expected
			);
			assert_eq!(
				vk::Instance::enumerate_physical_device_queue_family_performance_query_counters_khr(
					&fixture.instance,
					vk::PhysicalDevice::from_raw(305397760_u64 as _),
					Default::default(),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut u32,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::PerformanceCounterKHR<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784)
						as *mut vk::PerformanceCounterDescriptionKHR<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_physical_device_queue_family_performance_query_passes_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		vk::PhysicalDevice,
		*const vk::QueryPoolPerformanceCreateInfoKHR<'_>,
		*mut u32,
	) -> Result<(), CallError>;
	let _: Signature = vk::get_physical_device_queue_family_performance_query_passes_khr;
	let _: Signature = vk::Instance::get_physical_device_queue_family_performance_query_passes_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_physical_device_queue_family_performance_query_passes_khr(
				&fixture.instance,
				std::mem::zeroed::<vk::PhysicalDevice>(),
				std::mem::zeroed::<*const vk::QueryPoolPerformanceCreateInfoKHR<'_>>(),
				std::mem::zeroed::<*mut u32>()
			),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR"
			))
		));
		assert!(matches!(
			fixture
				.instance
				.get_physical_device_queue_family_performance_query_passes_khr(
					std::mem::zeroed::<vk::PhysicalDevice>(),
					std::mem::zeroed::<*const vk::QueryPoolPerformanceCreateInfoKHR<'_>>(),
					std::mem::zeroed::<*mut u32>()
				),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR"
			))
		));
	}
}

#[test]
fn get_physical_device_queue_family_performance_query_passes_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::PhysicalDevice,
		arg_1: *const vk::QueryPoolPerformanceCreateInfoKHR<'_>,
		arg_2: *mut u32,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::PhysicalDevice::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::QueryPoolPerformanceCreateInfoKHR<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut u32,
				)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(
			c"vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR",
			erased,
		);
		let resolutions = Fixture::query_count();
		vk::get_physical_device_queue_family_performance_query_passes_khr(
			&fixture.instance,
			vk::PhysicalDevice::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::QueryPoolPerformanceCreateInfoKHR<'_>,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut u32,
		)
		.unwrap();
		vk::Instance::get_physical_device_queue_family_performance_query_passes_khr(
			&fixture.instance,
			vk::PhysicalDevice::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::QueryPoolPerformanceCreateInfoKHR<'_>,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut u32,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn acquire_profiling_lock_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::AcquireProfilingLockInfoKHR<'_>,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::acquire_profiling_lock_khr;
	let _: Signature = vk::Device::acquire_profiling_lock_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::acquire_profiling_lock_khr(
				&fixture.device,
				std::mem::zeroed::<*const vk::AcquireProfilingLockInfoKHR<'_>>()
			),
			Err(CallError::MissingCommand("vkAcquireProfilingLockKHR"))
		));
		assert!(matches!(
			fixture
				.device
				.acquire_profiling_lock_khr(
					std::mem::zeroed::<*const vk::AcquireProfilingLockInfoKHR<'_>>()
				),
			Err(CallError::MissingCommand("vkAcquireProfilingLockKHR"))
		));
	}
}

#[test]
fn acquire_profiling_lock_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::AcquireProfilingLockInfoKHR<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::AcquireProfilingLockInfoKHR<'_>,
					)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkAcquireProfilingLockKHR = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkAcquireProfilingLockKHR, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkAcquireProfilingLockKHR", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::acquire_profiling_lock_khr(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::AcquireProfilingLockInfoKHR<'_>
				),
				expected
			);
			assert_eq!(
				vk::Device::acquire_profiling_lock_khr(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::AcquireProfilingLockInfoKHR<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn release_profiling_lock_khr_signature_and_missing_command() {
	type Signature = unsafe fn(&vk::Device) -> Result<(), CallError>;
	let _: Signature = vk::release_profiling_lock_khr;
	let _: Signature = vk::Device::release_profiling_lock_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::release_profiling_lock_khr(&fixture.device,),
			Err(CallError::MissingCommand("vkReleaseProfilingLockKHR"))
		));
		assert!(matches!(
			fixture.device.release_profiling_lock_khr(),
			Err(CallError::MissingCommand("vkReleaseProfilingLockKHR"))
		));
	}
}

#[test]
fn release_profiling_lock_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::DeviceHandle) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(MATCHED.get() && (arg_0 == vk::DeviceHandle::from_raw(0x2000)));
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkReleaseProfilingLockKHR = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkReleaseProfilingLockKHR, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkReleaseProfilingLockKHR", erased);
		let resolutions = Fixture::query_count();
		vk::release_profiling_lock_khr(&fixture.device).unwrap();
		vk::Device::release_profiling_lock_khr(&fixture.device).unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_image_drm_format_modifier_properties_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::Image,
		*mut vk::ImageDrmFormatModifierPropertiesEXT<'_>,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_image_drm_format_modifier_properties_ext;
	let _: Signature = vk::Device::get_image_drm_format_modifier_properties_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_image_drm_format_modifier_properties_ext(
				&fixture.device,
				std::mem::zeroed::<vk::Image>(),
				std::mem::zeroed::<*mut vk::ImageDrmFormatModifierPropertiesEXT<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetImageDrmFormatModifierPropertiesEXT"
			))
		));
		assert!(matches!(
			fixture.device.get_image_drm_format_modifier_properties_ext(
				std::mem::zeroed::<vk::Image>(),
				std::mem::zeroed::<*mut vk::ImageDrmFormatModifierPropertiesEXT<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetImageDrmFormatModifierPropertiesEXT"
			))
		));
	}
}

#[test]
fn get_image_drm_format_modifier_properties_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::Image,
		arg_2: *mut vk::ImageDrmFormatModifierPropertiesEXT<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::Image::from_raw(305398016_u64 as _)
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *mut vk::ImageDrmFormatModifierPropertiesEXT<'_>,
					)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetImageDrmFormatModifierPropertiesEXT = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetImageDrmFormatModifierPropertiesEXT,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkGetImageDrmFormatModifierPropertiesEXT", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_image_drm_format_modifier_properties_ext(
					&fixture.device,
					vk::Image::from_raw(305398016_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::ImageDrmFormatModifierPropertiesEXT<'_>
				),
				expected
			);
			assert_eq!(
				vk::Device::get_image_drm_format_modifier_properties_ext(
					&fixture.device,
					vk::Image::from_raw(305398016_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::ImageDrmFormatModifierPropertiesEXT<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_buffer_opaque_capture_address_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, &vk::BufferDeviceAddressInfo<'_>) -> Result<u64, CallError>;
	let _: Signature = vk::get_buffer_opaque_capture_address;
	let _: Signature = vk::Device::get_buffer_opaque_capture_address;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_buffer_opaque_capture_address(
				&fixture.device,
				&std::mem::zeroed::<vk::BufferDeviceAddressInfo<'_>>()
			),
			Err(CallError::MissingCommand("vkGetBufferOpaqueCaptureAddress"))
		));
		assert!(matches!(
			fixture
				.device
				.get_buffer_opaque_capture_address(&std::mem::zeroed::<vk::BufferDeviceAddressInfo<'_>>()),
			Err(CallError::MissingCommand("vkGetBufferOpaqueCaptureAddress"))
		));
	}
}

#[test]
fn get_buffer_opaque_capture_address_khr_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, &vk::BufferDeviceAddressInfo<'_>) -> Result<u64, CallError>;
	let _: Signature = vk::get_buffer_opaque_capture_address_khr;
	let _: Signature = vk::Device::get_buffer_opaque_capture_address_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_buffer_opaque_capture_address_khr(
				&fixture.device,
				&std::mem::zeroed::<vk::BufferDeviceAddressInfo<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetBufferOpaqueCaptureAddressKHR"
			))
		));
		assert!(matches!(
			fixture
				.device
				.get_buffer_opaque_capture_address_khr(
					&std::mem::zeroed::<vk::BufferDeviceAddressInfo<'_>>()
				),
			Err(CallError::MissingCommand(
				"vkGetBufferOpaqueCaptureAddressKHR"
			))
		));
	}
}

#[test]
fn get_buffer_device_address_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		&vk::BufferDeviceAddressInfo<'_>,
	) -> Result<vk::DeviceAddress, CallError>;
	let _: Signature = vk::get_buffer_device_address;
	let _: Signature = vk::Device::get_buffer_device_address;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_buffer_device_address(
				&fixture.device,
				&std::mem::zeroed::<vk::BufferDeviceAddressInfo<'_>>()
			),
			Err(CallError::MissingCommand("vkGetBufferDeviceAddress"))
		));
		assert!(matches!(
			fixture
				.device
				.get_buffer_device_address(&std::mem::zeroed::<vk::BufferDeviceAddressInfo<'_>>()),
			Err(CallError::MissingCommand("vkGetBufferDeviceAddress"))
		));
	}
}

#[test]
fn get_buffer_device_address_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		&vk::BufferDeviceAddressInfo<'_>,
	) -> Result<vk::DeviceAddress, CallError>;
	let _: Signature = vk::get_buffer_device_address_khr;
	let _: Signature = vk::Device::get_buffer_device_address_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_buffer_device_address_khr(
				&fixture.device,
				&std::mem::zeroed::<vk::BufferDeviceAddressInfo<'_>>()
			),
			Err(CallError::MissingCommand("vkGetBufferDeviceAddressKHR"))
		));
		assert!(matches!(
			fixture
				.device
				.get_buffer_device_address_khr(&std::mem::zeroed::<vk::BufferDeviceAddressInfo<'_>>()),
			Err(CallError::MissingCommand("vkGetBufferDeviceAddressKHR"))
		));
	}
}

#[test]
fn get_buffer_device_address_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		&vk::BufferDeviceAddressInfo<'_>,
	) -> Result<vk::DeviceAddress, CallError>;
	let _: Signature = vk::get_buffer_device_address_ext;
	let _: Signature = vk::Device::get_buffer_device_address_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_buffer_device_address_ext(
				&fixture.device,
				&std::mem::zeroed::<vk::BufferDeviceAddressInfo<'_>>()
			),
			Err(CallError::MissingCommand("vkGetBufferDeviceAddressEXT"))
		));
		assert!(matches!(
			fixture
				.device
				.get_buffer_device_address_ext(&std::mem::zeroed::<vk::BufferDeviceAddressInfo<'_>>()),
			Err(CallError::MissingCommand("vkGetBufferDeviceAddressEXT"))
		));
	}
}

#[test]
fn create_headless_surface_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		*const vk::HeadlessSurfaceCreateInfoEXT<'_>,
		*const vk::AllocationCallbacks,
		*mut vk::SurfaceKHR,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::create_headless_surface_ext;
	let _: Signature = vk::Instance::create_headless_surface_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::create_headless_surface_ext(
				&fixture.instance,
				std::mem::zeroed::<*const vk::HeadlessSurfaceCreateInfoEXT<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::SurfaceKHR>()
			),
			Err(CallError::MissingCommand("vkCreateHeadlessSurfaceEXT"))
		));
		assert!(matches!(
			fixture.instance.create_headless_surface_ext(
				std::mem::zeroed::<*const vk::HeadlessSurfaceCreateInfoEXT<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::SurfaceKHR>()
			),
			Err(CallError::MissingCommand("vkCreateHeadlessSurfaceEXT"))
		));
	}
}

#[test]
fn create_headless_surface_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::InstanceHandle,
		arg_1: *const vk::HeadlessSurfaceCreateInfoEXT<'_>,
		arg_2: *const vk::AllocationCallbacks,
		arg_3: *mut vk::SurfaceKHR,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::InstanceHandle::from_raw(0x1000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::HeadlessSurfaceCreateInfoEXT<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
				) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::SurfaceKHR,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCreateHeadlessSurfaceEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCreateHeadlessSurfaceEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCreateHeadlessSurfaceEXT", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::create_headless_surface_ext(
					&fixture.instance,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::HeadlessSurfaceCreateInfoEXT<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::SurfaceKHR
				),
				expected
			);
			assert_eq!(
				vk::Instance::create_headless_surface_ext(
					&fixture.instance,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::HeadlessSurfaceCreateInfoEXT<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::SurfaceKHR
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_physical_device_supported_framebuffer_mixed_samples_combinations_nv_signature_and_missing_command()
 {
	type Signature = unsafe fn(
		&vk::Instance,
		vk::PhysicalDevice,
		*mut u32,
		*mut vk::FramebufferMixedSamplesCombinationNV<'_>,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_physical_device_supported_framebuffer_mixed_samples_combinations_nv;
	let _: Signature =
		vk::Instance::get_physical_device_supported_framebuffer_mixed_samples_combinations_nv;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_physical_device_supported_framebuffer_mixed_samples_combinations_nv(
				&fixture.instance,
				std::mem::zeroed::<vk::PhysicalDevice>(),
				std::mem::zeroed::<*mut u32>(),
				std::mem::zeroed::<*mut vk::FramebufferMixedSamplesCombinationNV<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV"
			))
		));
		assert!(matches!(
			fixture
				.instance
				.get_physical_device_supported_framebuffer_mixed_samples_combinations_nv(
					std::mem::zeroed::<vk::PhysicalDevice>(),
					std::mem::zeroed::<*mut u32>(),
					std::mem::zeroed::<*mut vk::FramebufferMixedSamplesCombinationNV<'_>>()
				),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV"
			))
		));
	}
}

#[test]
fn get_physical_device_supported_framebuffer_mixed_samples_combinations_nv_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::PhysicalDevice,
		arg_1: *mut u32,
		arg_2: *mut vk::FramebufferMixedSamplesCombinationNV<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::PhysicalDevice::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016) as *mut u32,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::FramebufferMixedSamplesCombinationNV<'_>,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV =
			Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(
			c"vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV",
			erased,
		);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_physical_device_supported_framebuffer_mixed_samples_combinations_nv(
					&fixture.instance,
					vk::PhysicalDevice::from_raw(305397760_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016) as *mut u32,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::FramebufferMixedSamplesCombinationNV<'_>
				),
				expected
			);
			assert_eq!(
				vk::Instance::get_physical_device_supported_framebuffer_mixed_samples_combinations_nv(
					&fixture.instance,
					vk::PhysicalDevice::from_raw(305397760_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016) as *mut u32,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::FramebufferMixedSamplesCombinationNV<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn initialize_performance_api_intel_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::InitializePerformanceApiInfoINTEL<'_>,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::initialize_performance_api_intel;
	let _: Signature = vk::Device::initialize_performance_api_intel;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::initialize_performance_api_intel(
				&fixture.device,
				std::mem::zeroed::<*const vk::InitializePerformanceApiInfoINTEL<'_>>()
			),
			Err(CallError::MissingCommand("vkInitializePerformanceApiINTEL"))
		));
		assert!(matches!(
			fixture
				.device
				.initialize_performance_api_intel(std::mem::zeroed::<
					*const vk::InitializePerformanceApiInfoINTEL<'_>,
				>()),
			Err(CallError::MissingCommand("vkInitializePerformanceApiINTEL"))
		));
	}
}

#[test]
fn initialize_performance_api_intel_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::InitializePerformanceApiInfoINTEL<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::InitializePerformanceApiInfoINTEL<'_>,
					)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkInitializePerformanceApiINTEL = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkInitializePerformanceApiINTEL, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkInitializePerformanceApiINTEL", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::initialize_performance_api_intel(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::InitializePerformanceApiInfoINTEL<'_>
				),
				expected
			);
			assert_eq!(
				vk::Device::initialize_performance_api_intel(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::InitializePerformanceApiInfoINTEL<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn uninitialize_performance_api_intel_signature_and_missing_command() {
	type Signature = unsafe fn(&vk::Device) -> Result<(), CallError>;
	let _: Signature = vk::uninitialize_performance_api_intel;
	let _: Signature = vk::Device::uninitialize_performance_api_intel;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::uninitialize_performance_api_intel(&fixture.device,),
			Err(CallError::MissingCommand(
				"vkUninitializePerformanceApiINTEL"
			))
		));
		assert!(matches!(
			fixture.device.uninitialize_performance_api_intel(),
			Err(CallError::MissingCommand(
				"vkUninitializePerformanceApiINTEL"
			))
		));
	}
}

#[test]
fn uninitialize_performance_api_intel_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::DeviceHandle) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(MATCHED.get() && (arg_0 == vk::DeviceHandle::from_raw(0x2000)));
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkUninitializePerformanceApiINTEL = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkUninitializePerformanceApiINTEL,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkUninitializePerformanceApiINTEL", erased);
		let resolutions = Fixture::query_count();
		vk::uninitialize_performance_api_intel(&fixture.device).unwrap();
		vk::Device::uninitialize_performance_api_intel(&fixture.device).unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_set_performance_marker_intel_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		*const vk::PerformanceMarkerInfoINTEL<'_>,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::cmd_set_performance_marker_intel;
	let _: Signature = vk::Device::cmd_set_performance_marker_intel;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_performance_marker_intel(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::PerformanceMarkerInfoINTEL<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdSetPerformanceMarkerINTEL"))
		));
		assert!(matches!(
			fixture.device.cmd_set_performance_marker_intel(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::PerformanceMarkerInfoINTEL<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdSetPerformanceMarkerINTEL"))
		));
	}
}

#[test]
fn cmd_set_performance_marker_intel_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: *const vk::PerformanceMarkerInfoINTEL<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::PerformanceMarkerInfoINTEL<'_>,
					)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdSetPerformanceMarkerINTEL = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdSetPerformanceMarkerINTEL, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdSetPerformanceMarkerINTEL", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::cmd_set_performance_marker_intel(
					&fixture.device,
					vk::CommandBuffer::from_raw(305397760_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::PerformanceMarkerInfoINTEL<'_>
				),
				expected
			);
			assert_eq!(
				vk::Device::cmd_set_performance_marker_intel(
					&fixture.device,
					vk::CommandBuffer::from_raw(305397760_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::PerformanceMarkerInfoINTEL<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_set_performance_stream_marker_intel_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		*const vk::PerformanceStreamMarkerInfoINTEL<'_>,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::cmd_set_performance_stream_marker_intel;
	let _: Signature = vk::Device::cmd_set_performance_stream_marker_intel;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_performance_stream_marker_intel(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::PerformanceStreamMarkerInfoINTEL<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkCmdSetPerformanceStreamMarkerINTEL"
			))
		));
		assert!(matches!(
			fixture.device.cmd_set_performance_stream_marker_intel(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::PerformanceStreamMarkerInfoINTEL<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkCmdSetPerformanceStreamMarkerINTEL"
			))
		));
	}
}

#[test]
fn cmd_set_performance_stream_marker_intel_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: *const vk::PerformanceStreamMarkerInfoINTEL<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::PerformanceStreamMarkerInfoINTEL<'_>,
					)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdSetPerformanceStreamMarkerINTEL = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkCmdSetPerformanceStreamMarkerINTEL,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdSetPerformanceStreamMarkerINTEL", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::cmd_set_performance_stream_marker_intel(
					&fixture.device,
					vk::CommandBuffer::from_raw(305397760_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::PerformanceStreamMarkerInfoINTEL<'_>
				),
				expected
			);
			assert_eq!(
				vk::Device::cmd_set_performance_stream_marker_intel(
					&fixture.device,
					vk::CommandBuffer::from_raw(305397760_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::PerformanceStreamMarkerInfoINTEL<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_set_performance_override_intel_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		*const vk::PerformanceOverrideInfoINTEL<'_>,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::cmd_set_performance_override_intel;
	let _: Signature = vk::Device::cmd_set_performance_override_intel;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_performance_override_intel(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::PerformanceOverrideInfoINTEL<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkCmdSetPerformanceOverrideINTEL"
			))
		));
		assert!(matches!(
			fixture.device.cmd_set_performance_override_intel(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::PerformanceOverrideInfoINTEL<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkCmdSetPerformanceOverrideINTEL"
			))
		));
	}
}

#[test]
fn cmd_set_performance_override_intel_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: *const vk::PerformanceOverrideInfoINTEL<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::PerformanceOverrideInfoINTEL<'_>,
					)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdSetPerformanceOverrideINTEL = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkCmdSetPerformanceOverrideINTEL,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdSetPerformanceOverrideINTEL", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::cmd_set_performance_override_intel(
					&fixture.device,
					vk::CommandBuffer::from_raw(305397760_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::PerformanceOverrideInfoINTEL<'_>
				),
				expected
			);
			assert_eq!(
				vk::Device::cmd_set_performance_override_intel(
					&fixture.device,
					vk::CommandBuffer::from_raw(305397760_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::PerformanceOverrideInfoINTEL<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn acquire_performance_configuration_intel_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::PerformanceConfigurationAcquireInfoINTEL<'_>,
		*mut vk::PerformanceConfigurationINTEL,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::acquire_performance_configuration_intel;
	let _: Signature = vk::Device::acquire_performance_configuration_intel;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::acquire_performance_configuration_intel(
				&fixture.device,
				std::mem::zeroed::<*const vk::PerformanceConfigurationAcquireInfoINTEL<'_>>(),
				std::mem::zeroed::<*mut vk::PerformanceConfigurationINTEL>()
			),
			Err(CallError::MissingCommand(
				"vkAcquirePerformanceConfigurationINTEL"
			))
		));
		assert!(matches!(
			fixture.device.acquire_performance_configuration_intel(
				std::mem::zeroed::<*const vk::PerformanceConfigurationAcquireInfoINTEL<'_>>(),
				std::mem::zeroed::<*mut vk::PerformanceConfigurationINTEL>()
			),
			Err(CallError::MissingCommand(
				"vkAcquirePerformanceConfigurationINTEL"
			))
		));
	}
}

#[test]
fn acquire_performance_configuration_intel_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::PerformanceConfigurationAcquireInfoINTEL<'_>,
		arg_2: *mut vk::PerformanceConfigurationINTEL,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::PerformanceConfigurationAcquireInfoINTEL<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::PerformanceConfigurationINTEL,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkAcquirePerformanceConfigurationINTEL = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkAcquirePerformanceConfigurationINTEL,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkAcquirePerformanceConfigurationINTEL", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::acquire_performance_configuration_intel(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::PerformanceConfigurationAcquireInfoINTEL<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::PerformanceConfigurationINTEL
				),
				expected
			);
			assert_eq!(
				vk::Device::acquire_performance_configuration_intel(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::PerformanceConfigurationAcquireInfoINTEL<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::PerformanceConfigurationINTEL
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn release_performance_configuration_intel_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, vk::PerformanceConfigurationINTEL) -> Result<vk::Result, CallError>;
	let _: Signature = vk::release_performance_configuration_intel;
	let _: Signature = vk::Device::release_performance_configuration_intel;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::release_performance_configuration_intel(
				&fixture.device,
				std::mem::zeroed::<vk::PerformanceConfigurationINTEL>()
			),
			Err(CallError::MissingCommand(
				"vkReleasePerformanceConfigurationINTEL"
			))
		));
		assert!(matches!(
			fixture
				.device
				.release_performance_configuration_intel(std::mem::zeroed::<
					vk::PerformanceConfigurationINTEL,
				>()),
			Err(CallError::MissingCommand(
				"vkReleasePerformanceConfigurationINTEL"
			))
		));
	}
}

#[test]
fn release_performance_configuration_intel_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::PerformanceConfigurationINTEL,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::PerformanceConfigurationINTEL::from_raw(305398016_u64 as _)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkReleasePerformanceConfigurationINTEL = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkReleasePerformanceConfigurationINTEL,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkReleasePerformanceConfigurationINTEL", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::release_performance_configuration_intel(
					&fixture.device,
					vk::PerformanceConfigurationINTEL::from_raw(305398016_u64 as _)
				),
				expected
			);
			assert_eq!(
				vk::Device::release_performance_configuration_intel(
					&fixture.device,
					vk::PerformanceConfigurationINTEL::from_raw(305398016_u64 as _)
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn queue_set_performance_configuration_intel_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::Queue,
		vk::PerformanceConfigurationINTEL,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::queue_set_performance_configuration_intel;
	let _: Signature = vk::Device::queue_set_performance_configuration_intel;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::queue_set_performance_configuration_intel(
				&fixture.device,
				std::mem::zeroed::<vk::Queue>(),
				std::mem::zeroed::<vk::PerformanceConfigurationINTEL>()
			),
			Err(CallError::MissingCommand(
				"vkQueueSetPerformanceConfigurationINTEL"
			))
		));
		assert!(matches!(
			fixture.device.queue_set_performance_configuration_intel(
				std::mem::zeroed::<vk::Queue>(),
				std::mem::zeroed::<vk::PerformanceConfigurationINTEL>()
			),
			Err(CallError::MissingCommand(
				"vkQueueSetPerformanceConfigurationINTEL"
			))
		));
	}
}

#[test]
fn queue_set_performance_configuration_intel_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::Queue,
		arg_1: vk::PerformanceConfigurationINTEL,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::Queue::from_raw(305397760_u64 as _)
					&& arg_1 == vk::PerformanceConfigurationINTEL::from_raw(305398016_u64 as _)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkQueueSetPerformanceConfigurationINTEL = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkQueueSetPerformanceConfigurationINTEL,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkQueueSetPerformanceConfigurationINTEL", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::queue_set_performance_configuration_intel(
					&fixture.device,
					vk::Queue::from_raw(305397760_u64 as _),
					vk::PerformanceConfigurationINTEL::from_raw(305398016_u64 as _)
				),
				expected
			);
			assert_eq!(
				vk::Device::queue_set_performance_configuration_intel(
					&fixture.device,
					vk::Queue::from_raw(305397760_u64 as _),
					vk::PerformanceConfigurationINTEL::from_raw(305398016_u64 as _)
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_performance_parameter_intel_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::PerformanceParameterTypeINTEL,
		*mut vk::PerformanceValueINTEL<'_>,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_performance_parameter_intel;
	let _: Signature = vk::Device::get_performance_parameter_intel;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_performance_parameter_intel(
				&fixture.device,
				std::mem::zeroed::<vk::PerformanceParameterTypeINTEL>(),
				std::mem::zeroed::<*mut vk::PerformanceValueINTEL<'_>>()
			),
			Err(CallError::MissingCommand("vkGetPerformanceParameterINTEL"))
		));
		assert!(matches!(
			fixture.device.get_performance_parameter_intel(
				std::mem::zeroed::<vk::PerformanceParameterTypeINTEL>(),
				std::mem::zeroed::<*mut vk::PerformanceValueINTEL<'_>>()
			),
			Err(CallError::MissingCommand("vkGetPerformanceParameterINTEL"))
		));
	}
}

#[test]
fn get_performance_parameter_intel_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::PerformanceParameterTypeINTEL,
		arg_2: *mut vk::PerformanceValueINTEL<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::PerformanceParameterTypeINTEL::from_raw(305398016_u64 as _)
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *mut vk::PerformanceValueINTEL<'_>,
					)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetPerformanceParameterINTEL = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkGetPerformanceParameterINTEL, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkGetPerformanceParameterINTEL", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_performance_parameter_intel(
					&fixture.device,
					vk::PerformanceParameterTypeINTEL::from_raw(305398016_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::PerformanceValueINTEL<'_>
				),
				expected
			);
			assert_eq!(
				vk::Device::get_performance_parameter_intel(
					&fixture.device,
					vk::PerformanceParameterTypeINTEL::from_raw(305398016_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::PerformanceValueINTEL<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_device_memory_opaque_capture_address_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, &vk::DeviceMemoryOpaqueCaptureAddressInfo<'_>) -> Result<u64, CallError>;
	let _: Signature = vk::get_device_memory_opaque_capture_address;
	let _: Signature = vk::Device::get_device_memory_opaque_capture_address;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_device_memory_opaque_capture_address(
				&fixture.device,
				&std::mem::zeroed::<vk::DeviceMemoryOpaqueCaptureAddressInfo<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetDeviceMemoryOpaqueCaptureAddress"
			))
		));
		assert!(matches!(
			fixture
				.device
				.get_device_memory_opaque_capture_address(&std::mem::zeroed::<
					vk::DeviceMemoryOpaqueCaptureAddressInfo<'_>,
				>()),
			Err(CallError::MissingCommand(
				"vkGetDeviceMemoryOpaqueCaptureAddress"
			))
		));
	}
}

#[test]
fn get_device_memory_opaque_capture_address_khr_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, &vk::DeviceMemoryOpaqueCaptureAddressInfo<'_>) -> Result<u64, CallError>;
	let _: Signature = vk::get_device_memory_opaque_capture_address_khr;
	let _: Signature = vk::Device::get_device_memory_opaque_capture_address_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_device_memory_opaque_capture_address_khr(
				&fixture.device,
				&std::mem::zeroed::<vk::DeviceMemoryOpaqueCaptureAddressInfo<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetDeviceMemoryOpaqueCaptureAddressKHR"
			))
		));
		assert!(matches!(
			fixture
				.device
				.get_device_memory_opaque_capture_address_khr(&std::mem::zeroed::<
					vk::DeviceMemoryOpaqueCaptureAddressInfo<'_>,
				>()),
			Err(CallError::MissingCommand(
				"vkGetDeviceMemoryOpaqueCaptureAddressKHR"
			))
		));
	}
}

#[test]
fn get_pipeline_executable_properties_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::PipelineInfoKHR<'_>,
		*mut u32,
		*mut vk::PipelineExecutablePropertiesKHR<'_>,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_pipeline_executable_properties_khr;
	let _: Signature = vk::Device::get_pipeline_executable_properties_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_pipeline_executable_properties_khr(
				&fixture.device,
				std::mem::zeroed::<*const vk::PipelineInfoKHR<'_>>(),
				std::mem::zeroed::<*mut u32>(),
				std::mem::zeroed::<*mut vk::PipelineExecutablePropertiesKHR<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetPipelineExecutablePropertiesKHR"
			))
		));
		assert!(matches!(
			fixture.device.get_pipeline_executable_properties_khr(
				std::mem::zeroed::<*const vk::PipelineInfoKHR<'_>>(),
				std::mem::zeroed::<*mut u32>(),
				std::mem::zeroed::<*mut vk::PipelineExecutablePropertiesKHR<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetPipelineExecutablePropertiesKHR"
			))
		));
	}
}

#[test]
fn get_pipeline_executable_properties_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::PipelineInfoKHR<'_>,
		arg_2: *mut u32,
		arg_3: *mut vk::PipelineExecutablePropertiesKHR<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::PipelineInfoKHR<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut u32,
				) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::PipelineExecutablePropertiesKHR<'_>,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetPipelineExecutablePropertiesKHR = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetPipelineExecutablePropertiesKHR,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkGetPipelineExecutablePropertiesKHR", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_pipeline_executable_properties_khr(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::PipelineInfoKHR<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut u32,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::PipelineExecutablePropertiesKHR<'_>
				),
				expected
			);
			assert_eq!(
				vk::Device::get_pipeline_executable_properties_khr(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::PipelineInfoKHR<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut u32,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::PipelineExecutablePropertiesKHR<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_pipeline_executable_statistics_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::PipelineExecutableInfoKHR<'_>,
		*mut u32,
		*mut vk::PipelineExecutableStatisticKHR<'_>,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_pipeline_executable_statistics_khr;
	let _: Signature = vk::Device::get_pipeline_executable_statistics_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_pipeline_executable_statistics_khr(
				&fixture.device,
				std::mem::zeroed::<*const vk::PipelineExecutableInfoKHR<'_>>(),
				std::mem::zeroed::<*mut u32>(),
				std::mem::zeroed::<*mut vk::PipelineExecutableStatisticKHR<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetPipelineExecutableStatisticsKHR"
			))
		));
		assert!(matches!(
			fixture.device.get_pipeline_executable_statistics_khr(
				std::mem::zeroed::<*const vk::PipelineExecutableInfoKHR<'_>>(),
				std::mem::zeroed::<*mut u32>(),
				std::mem::zeroed::<*mut vk::PipelineExecutableStatisticKHR<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetPipelineExecutableStatisticsKHR"
			))
		));
	}
}

#[test]
fn get_pipeline_executable_statistics_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::PipelineExecutableInfoKHR<'_>,
		arg_2: *mut u32,
		arg_3: *mut vk::PipelineExecutableStatisticKHR<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::PipelineExecutableInfoKHR<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut u32,
				) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::PipelineExecutableStatisticKHR<'_>,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetPipelineExecutableStatisticsKHR = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetPipelineExecutableStatisticsKHR,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkGetPipelineExecutableStatisticsKHR", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_pipeline_executable_statistics_khr(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::PipelineExecutableInfoKHR<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut u32,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::PipelineExecutableStatisticKHR<'_>
				),
				expected
			);
			assert_eq!(
				vk::Device::get_pipeline_executable_statistics_khr(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::PipelineExecutableInfoKHR<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut u32,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::PipelineExecutableStatisticKHR<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_pipeline_executable_internal_representations_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::PipelineExecutableInfoKHR<'_>,
		*mut u32,
		*mut vk::PipelineExecutableInternalRepresentationKHR<'_>,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_pipeline_executable_internal_representations_khr;
	let _: Signature = vk::Device::get_pipeline_executable_internal_representations_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_pipeline_executable_internal_representations_khr(
				&fixture.device,
				std::mem::zeroed::<*const vk::PipelineExecutableInfoKHR<'_>>(),
				std::mem::zeroed::<*mut u32>(),
				std::mem::zeroed::<*mut vk::PipelineExecutableInternalRepresentationKHR<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetPipelineExecutableInternalRepresentationsKHR"
			))
		));
		assert!(matches!(
			fixture
				.device
				.get_pipeline_executable_internal_representations_khr(
					std::mem::zeroed::<*const vk::PipelineExecutableInfoKHR<'_>>(),
					std::mem::zeroed::<*mut u32>(),
					std::mem::zeroed::<*mut vk::PipelineExecutableInternalRepresentationKHR<'_>>()
				),
			Err(CallError::MissingCommand(
				"vkGetPipelineExecutableInternalRepresentationsKHR"
			))
		));
	}
}

#[test]
fn get_pipeline_executable_internal_representations_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::PipelineExecutableInfoKHR<'_>,
		arg_2: *mut u32,
		arg_3: *mut vk::PipelineExecutableInternalRepresentationKHR<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::PipelineExecutableInfoKHR<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut u32,
				) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::PipelineExecutableInternalRepresentationKHR<'_>,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetPipelineExecutableInternalRepresentationsKHR = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetPipelineExecutableInternalRepresentationsKHR,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture =
			Fixture::new_with_command(c"vkGetPipelineExecutableInternalRepresentationsKHR", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_pipeline_executable_internal_representations_khr(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::PipelineExecutableInfoKHR<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut u32,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::PipelineExecutableInternalRepresentationKHR<'_>
				),
				expected
			);
			assert_eq!(
				vk::Device::get_pipeline_executable_internal_representations_khr(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::PipelineExecutableInfoKHR<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut u32,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::PipelineExecutableInternalRepresentationKHR<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_set_line_stipple_signature_and_missing_command() {
	type Signature = unsafe fn(&vk::Device, vk::CommandBuffer, u32, u16) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_line_stipple;
	let _: Signature = vk::Device::cmd_set_line_stipple;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_line_stipple(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u16>()
			),
			Err(CallError::MissingCommand("vkCmdSetLineStipple"))
		));
		assert!(matches!(
			fixture.device.cmd_set_line_stipple(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u16>()
			),
			Err(CallError::MissingCommand("vkCmdSetLineStipple"))
		));
	}
}

#[test]
fn cmd_set_line_stipple_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::CommandBuffer, arg_1: u32, arg_2: u16) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == Default::default()
					&& arg_2 == Default::default()),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdSetLineStipple = Some(mock);
		let erased = std::mem::transmute::<vk::PFN_vkCmdSetLineStipple, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdSetLineStipple", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_set_line_stipple(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
			Default::default(),
		)
		.unwrap();
		vk::Device::cmd_set_line_stipple(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
			Default::default(),
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_set_line_stipple_khr_signature_and_missing_command() {
	type Signature = unsafe fn(&vk::Device, vk::CommandBuffer, u32, u16) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_line_stipple_khr;
	let _: Signature = vk::Device::cmd_set_line_stipple_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_line_stipple_khr(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u16>()
			),
			Err(CallError::MissingCommand("vkCmdSetLineStippleKHR"))
		));
		assert!(matches!(
			fixture.device.cmd_set_line_stipple_khr(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u16>()
			),
			Err(CallError::MissingCommand("vkCmdSetLineStippleKHR"))
		));
	}
}

#[test]
fn cmd_set_line_stipple_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::CommandBuffer, arg_1: u32, arg_2: u16) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == Default::default()
					&& arg_2 == Default::default()),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdSetLineStippleKHR = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdSetLineStippleKHR, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdSetLineStippleKHR", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_set_line_stipple_khr(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
			Default::default(),
		)
		.unwrap();
		vk::Device::cmd_set_line_stipple_khr(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
			Default::default(),
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_set_line_stipple_ext_signature_and_missing_command() {
	type Signature = unsafe fn(&vk::Device, vk::CommandBuffer, u32, u16) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_line_stipple_ext;
	let _: Signature = vk::Device::cmd_set_line_stipple_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_line_stipple_ext(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u16>()
			),
			Err(CallError::MissingCommand("vkCmdSetLineStippleEXT"))
		));
		assert!(matches!(
			fixture.device.cmd_set_line_stipple_ext(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u16>()
			),
			Err(CallError::MissingCommand("vkCmdSetLineStippleEXT"))
		));
	}
}

#[test]
fn cmd_set_line_stipple_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::CommandBuffer, arg_1: u32, arg_2: u16) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == Default::default()
					&& arg_2 == Default::default()),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdSetLineStippleEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdSetLineStippleEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdSetLineStippleEXT", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_set_line_stipple_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
			Default::default(),
		)
		.unwrap();
		vk::Device::cmd_set_line_stipple_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
			Default::default(),
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_physical_device_tool_properties_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		vk::PhysicalDevice,
		*mut u32,
		*mut vk::PhysicalDeviceToolProperties<'_>,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_physical_device_tool_properties;
	let _: Signature = vk::Instance::get_physical_device_tool_properties;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_physical_device_tool_properties(
				&fixture.instance,
				std::mem::zeroed::<vk::PhysicalDevice>(),
				std::mem::zeroed::<*mut u32>(),
				std::mem::zeroed::<*mut vk::PhysicalDeviceToolProperties<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceToolProperties"
			))
		));
		assert!(matches!(
			fixture.instance.get_physical_device_tool_properties(
				std::mem::zeroed::<vk::PhysicalDevice>(),
				std::mem::zeroed::<*mut u32>(),
				std::mem::zeroed::<*mut vk::PhysicalDeviceToolProperties<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceToolProperties"
			))
		));
	}
}

#[test]
fn get_physical_device_tool_properties_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::PhysicalDevice,
		arg_1: *mut u32,
		arg_2: *mut vk::PhysicalDeviceToolProperties<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::PhysicalDevice::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016) as *mut u32,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::PhysicalDeviceToolProperties<'_>,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetPhysicalDeviceToolProperties = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetPhysicalDeviceToolProperties,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkGetPhysicalDeviceToolProperties", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_physical_device_tool_properties(
					&fixture.instance,
					vk::PhysicalDevice::from_raw(305397760_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016) as *mut u32,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::PhysicalDeviceToolProperties<'_>
				),
				expected
			);
			assert_eq!(
				vk::Instance::get_physical_device_tool_properties(
					&fixture.instance,
					vk::PhysicalDevice::from_raw(305397760_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016) as *mut u32,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::PhysicalDeviceToolProperties<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_physical_device_tool_properties_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		vk::PhysicalDevice,
		*mut u32,
		*mut vk::PhysicalDeviceToolProperties<'_>,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_physical_device_tool_properties_ext;
	let _: Signature = vk::Instance::get_physical_device_tool_properties_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_physical_device_tool_properties_ext(
				&fixture.instance,
				std::mem::zeroed::<vk::PhysicalDevice>(),
				std::mem::zeroed::<*mut u32>(),
				std::mem::zeroed::<*mut vk::PhysicalDeviceToolProperties<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceToolPropertiesEXT"
			))
		));
		assert!(matches!(
			fixture.instance.get_physical_device_tool_properties_ext(
				std::mem::zeroed::<vk::PhysicalDevice>(),
				std::mem::zeroed::<*mut u32>(),
				std::mem::zeroed::<*mut vk::PhysicalDeviceToolProperties<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceToolPropertiesEXT"
			))
		));
	}
}

#[test]
fn get_physical_device_tool_properties_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::PhysicalDevice,
		arg_1: *mut u32,
		arg_2: *mut vk::PhysicalDeviceToolProperties<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::PhysicalDevice::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016) as *mut u32,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::PhysicalDeviceToolProperties<'_>,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetPhysicalDeviceToolPropertiesEXT = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetPhysicalDeviceToolPropertiesEXT,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkGetPhysicalDeviceToolPropertiesEXT", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_physical_device_tool_properties_ext(
					&fixture.instance,
					vk::PhysicalDevice::from_raw(305397760_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016) as *mut u32,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::PhysicalDeviceToolProperties<'_>
				),
				expected
			);
			assert_eq!(
				vk::Instance::get_physical_device_tool_properties_ext(
					&fixture.instance,
					vk::PhysicalDevice::from_raw(305397760_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016) as *mut u32,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::PhysicalDeviceToolProperties<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn create_acceleration_structure_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::AccelerationStructureCreateInfoKHR<'_>,
		*const vk::AllocationCallbacks,
		*mut vk::AccelerationStructureKHR,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::create_acceleration_structure_khr;
	let _: Signature = vk::Device::create_acceleration_structure_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::create_acceleration_structure_khr(
				&fixture.device,
				std::mem::zeroed::<*const vk::AccelerationStructureCreateInfoKHR<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::AccelerationStructureKHR>()
			),
			Err(CallError::MissingCommand(
				"vkCreateAccelerationStructureKHR"
			))
		));
		assert!(matches!(
			fixture.device.create_acceleration_structure_khr(
				std::mem::zeroed::<*const vk::AccelerationStructureCreateInfoKHR<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::AccelerationStructureKHR>()
			),
			Err(CallError::MissingCommand(
				"vkCreateAccelerationStructureKHR"
			))
		));
	}
}

#[test]
fn create_acceleration_structure_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::AccelerationStructureCreateInfoKHR<'_>,
		arg_2: *const vk::AllocationCallbacks,
		arg_3: *mut vk::AccelerationStructureKHR,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::AccelerationStructureCreateInfoKHR<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
				) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::AccelerationStructureKHR,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCreateAccelerationStructureKHR = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkCreateAccelerationStructureKHR,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkCreateAccelerationStructureKHR", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::create_acceleration_structure_khr(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::AccelerationStructureCreateInfoKHR<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::AccelerationStructureKHR
				),
				expected
			);
			assert_eq!(
				vk::Device::create_acceleration_structure_khr(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::AccelerationStructureCreateInfoKHR<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::AccelerationStructureKHR
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_build_acceleration_structures_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		u32,
		*const vk::AccelerationStructureBuildGeometryInfoKHR<'_>,
		*const *const vk::AccelerationStructureBuildRangeInfoKHR,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_build_acceleration_structures_khr;
	let _: Signature = vk::Device::cmd_build_acceleration_structures_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_build_acceleration_structures_khr(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::AccelerationStructureBuildGeometryInfoKHR<'_>>(),
				std::mem::zeroed::<*const *const vk::AccelerationStructureBuildRangeInfoKHR>()
			),
			Err(CallError::MissingCommand(
				"vkCmdBuildAccelerationStructuresKHR"
			))
		));
		assert!(matches!(
			fixture.device.cmd_build_acceleration_structures_khr(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::AccelerationStructureBuildGeometryInfoKHR<'_>>(),
				std::mem::zeroed::<*const *const vk::AccelerationStructureBuildRangeInfoKHR>()
			),
			Err(CallError::MissingCommand(
				"vkCmdBuildAccelerationStructuresKHR"
			))
		));
	}
}

#[test]
fn cmd_build_acceleration_structures_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: u32,
		arg_2: *const vk::AccelerationStructureBuildGeometryInfoKHR<'_>,
		arg_3: *const *const vk::AccelerationStructureBuildRangeInfoKHR,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == Default::default()
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *const vk::AccelerationStructureBuildGeometryInfoKHR<'_>,
					) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *const *const vk::AccelerationStructureBuildRangeInfoKHR,
				)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdBuildAccelerationStructuresKHR = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkCmdBuildAccelerationStructuresKHR,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdBuildAccelerationStructuresKHR", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_build_acceleration_structures_khr(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::AccelerationStructureBuildGeometryInfoKHR<'_>,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
				as *const *const vk::AccelerationStructureBuildRangeInfoKHR,
		)
		.unwrap();
		vk::Device::cmd_build_acceleration_structures_khr(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::AccelerationStructureBuildGeometryInfoKHR<'_>,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
				as *const *const vk::AccelerationStructureBuildRangeInfoKHR,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_build_acceleration_structures_indirect_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		u32,
		*const vk::AccelerationStructureBuildGeometryInfoKHR<'_>,
		*const vk::DeviceAddress,
		*const u32,
		*const *const u32,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_build_acceleration_structures_indirect_khr;
	let _: Signature = vk::Device::cmd_build_acceleration_structures_indirect_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_build_acceleration_structures_indirect_khr(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::AccelerationStructureBuildGeometryInfoKHR<'_>>(),
				std::mem::zeroed::<*const vk::DeviceAddress>(),
				std::mem::zeroed::<*const u32>(),
				std::mem::zeroed::<*const *const u32>()
			),
			Err(CallError::MissingCommand(
				"vkCmdBuildAccelerationStructuresIndirectKHR"
			))
		));
		assert!(matches!(
			fixture
				.device
				.cmd_build_acceleration_structures_indirect_khr(
					std::mem::zeroed::<vk::CommandBuffer>(),
					std::mem::zeroed::<u32>(),
					std::mem::zeroed::<*const vk::AccelerationStructureBuildGeometryInfoKHR<'_>>(),
					std::mem::zeroed::<*const vk::DeviceAddress>(),
					std::mem::zeroed::<*const u32>(),
					std::mem::zeroed::<*const *const u32>()
				),
			Err(CallError::MissingCommand(
				"vkCmdBuildAccelerationStructuresIndirectKHR"
			))
		));
	}
}

#[test]
fn cmd_build_acceleration_structures_indirect_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: u32,
		arg_2: *const vk::AccelerationStructureBuildGeometryInfoKHR<'_>,
		arg_3: *const vk::DeviceAddress,
		arg_4: *const u32,
		arg_5: *const *const u32,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == Default::default()
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *const vk::AccelerationStructureBuildGeometryInfoKHR<'_>,
					) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *const vk::DeviceAddress,
				) && std::ptr::eq(
					arg_4,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784) as *const u32,
				) && std::ptr::eq(
					arg_5,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305399040) as *const *const u32,
				)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdBuildAccelerationStructuresIndirectKHR = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkCmdBuildAccelerationStructuresIndirectKHR,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdBuildAccelerationStructuresIndirectKHR", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_build_acceleration_structures_indirect_khr(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::AccelerationStructureBuildGeometryInfoKHR<'_>,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *const vk::DeviceAddress,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784) as *const u32,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305399040) as *const *const u32,
		)
		.unwrap();
		vk::Device::cmd_build_acceleration_structures_indirect_khr(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::AccelerationStructureBuildGeometryInfoKHR<'_>,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *const vk::DeviceAddress,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784) as *const u32,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305399040) as *const *const u32,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn build_acceleration_structures_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::DeferredOperationKHR,
		u32,
		*const vk::AccelerationStructureBuildGeometryInfoKHR<'_>,
		*const *const vk::AccelerationStructureBuildRangeInfoKHR,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::build_acceleration_structures_khr;
	let _: Signature = vk::Device::build_acceleration_structures_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::build_acceleration_structures_khr(
				&fixture.device,
				std::mem::zeroed::<vk::DeferredOperationKHR>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::AccelerationStructureBuildGeometryInfoKHR<'_>>(),
				std::mem::zeroed::<*const *const vk::AccelerationStructureBuildRangeInfoKHR>()
			),
			Err(CallError::MissingCommand(
				"vkBuildAccelerationStructuresKHR"
			))
		));
		assert!(matches!(
			fixture.device.build_acceleration_structures_khr(
				std::mem::zeroed::<vk::DeferredOperationKHR>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::AccelerationStructureBuildGeometryInfoKHR<'_>>(),
				std::mem::zeroed::<*const *const vk::AccelerationStructureBuildRangeInfoKHR>()
			),
			Err(CallError::MissingCommand(
				"vkBuildAccelerationStructuresKHR"
			))
		));
	}
}

#[test]
fn build_acceleration_structures_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::DeferredOperationKHR,
		arg_2: u32,
		arg_3: *const vk::AccelerationStructureBuildGeometryInfoKHR<'_>,
		arg_4: *const *const vk::AccelerationStructureBuildRangeInfoKHR,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::DeferredOperationKHR::from_raw(305398016_u64 as _)
					&& arg_2 == Default::default()
					&& std::ptr::eq(
						arg_3,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
							as *const vk::AccelerationStructureBuildGeometryInfoKHR<'_>,
					) && std::ptr::eq(
					arg_4,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784)
						as *const *const vk::AccelerationStructureBuildRangeInfoKHR,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkBuildAccelerationStructuresKHR = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkBuildAccelerationStructuresKHR,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkBuildAccelerationStructuresKHR", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::build_acceleration_structures_khr(
					&fixture.device,
					vk::DeferredOperationKHR::from_raw(305398016_u64 as _),
					Default::default(),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *const vk::AccelerationStructureBuildGeometryInfoKHR<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784)
						as *const *const vk::AccelerationStructureBuildRangeInfoKHR
				),
				expected
			);
			assert_eq!(
				vk::Device::build_acceleration_structures_khr(
					&fixture.device,
					vk::DeferredOperationKHR::from_raw(305398016_u64 as _),
					Default::default(),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *const vk::AccelerationStructureBuildGeometryInfoKHR<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784)
						as *const *const vk::AccelerationStructureBuildRangeInfoKHR
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_acceleration_structure_device_address_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::AccelerationStructureDeviceAddressInfoKHR<'_>,
	) -> Result<vk::DeviceAddress, CallError>;
	let _: Signature = vk::get_acceleration_structure_device_address_khr;
	let _: Signature = vk::Device::get_acceleration_structure_device_address_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_acceleration_structure_device_address_khr(
				&fixture.device,
				std::mem::zeroed::<*const vk::AccelerationStructureDeviceAddressInfoKHR<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetAccelerationStructureDeviceAddressKHR"
			))
		));
		assert!(matches!(
			fixture
				.device
				.get_acceleration_structure_device_address_khr(std::mem::zeroed::<
					*const vk::AccelerationStructureDeviceAddressInfoKHR<'_>,
				>()),
			Err(CallError::MissingCommand(
				"vkGetAccelerationStructureDeviceAddressKHR"
			))
		));
	}
}

#[test]
fn get_acceleration_structure_device_address_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::AccelerationStructureDeviceAddressInfoKHR<'_>,
	) -> vk::DeviceAddress {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::AccelerationStructureDeviceAddressInfoKHR<'_>,
					)),
		);
		0xfedc_ba98_7654_3210_u64 as vk::DeviceAddress
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetAccelerationStructureDeviceAddressKHR = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetAccelerationStructureDeviceAddressKHR,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkGetAccelerationStructureDeviceAddressKHR", erased);
		let resolutions = Fixture::query_count();
		assert_eq!(
			vk::get_acceleration_structure_device_address_khr(
				&fixture.device,
				std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
					as *const vk::AccelerationStructureDeviceAddressInfoKHR<'_>
			)
			.unwrap(),
			0xfedc_ba98_7654_3210_u64 as vk::DeviceAddress
		);
		assert_eq!(
			vk::Device::get_acceleration_structure_device_address_khr(
				&fixture.device,
				std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
					as *const vk::AccelerationStructureDeviceAddressInfoKHR<'_>
			)
			.unwrap(),
			0xfedc_ba98_7654_3210_u64 as vk::DeviceAddress
		);
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn create_deferred_operation_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::AllocationCallbacks,
		*mut vk::DeferredOperationKHR,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::create_deferred_operation_khr;
	let _: Signature = vk::Device::create_deferred_operation_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::create_deferred_operation_khr(
				&fixture.device,
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::DeferredOperationKHR>()
			),
			Err(CallError::MissingCommand("vkCreateDeferredOperationKHR"))
		));
		assert!(matches!(
			fixture.device.create_deferred_operation_khr(
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::DeferredOperationKHR>()
			),
			Err(CallError::MissingCommand("vkCreateDeferredOperationKHR"))
		));
	}
}

#[test]
fn create_deferred_operation_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::AllocationCallbacks,
		arg_2: *mut vk::DeferredOperationKHR,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::AllocationCallbacks,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::DeferredOperationKHR,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCreateDeferredOperationKHR = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCreateDeferredOperationKHR, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCreateDeferredOperationKHR", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::create_deferred_operation_khr(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::DeferredOperationKHR
				),
				expected
			);
			assert_eq!(
				vk::Device::create_deferred_operation_khr(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::DeferredOperationKHR
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn destroy_deferred_operation_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::DeferredOperationKHR,
		*const vk::AllocationCallbacks,
	) -> Result<(), CallError>;
	let _: Signature = vk::destroy_deferred_operation_khr;
	let _: Signature = vk::Device::destroy_deferred_operation_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::destroy_deferred_operation_khr(
				&fixture.device,
				std::mem::zeroed::<vk::DeferredOperationKHR>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>()
			),
			Err(CallError::MissingCommand("vkDestroyDeferredOperationKHR"))
		));
		assert!(matches!(
			fixture.device.destroy_deferred_operation_khr(
				std::mem::zeroed::<vk::DeferredOperationKHR>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>()
			),
			Err(CallError::MissingCommand("vkDestroyDeferredOperationKHR"))
		));
	}
}

#[test]
fn destroy_deferred_operation_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::DeferredOperationKHR,
		arg_2: *const vk::AllocationCallbacks,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::DeferredOperationKHR::from_raw(305398016_u64 as _)
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *const vk::AllocationCallbacks,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkDestroyDeferredOperationKHR = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkDestroyDeferredOperationKHR, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkDestroyDeferredOperationKHR", erased);
		let resolutions = Fixture::query_count();
		vk::destroy_deferred_operation_khr(
			&fixture.device,
			vk::DeferredOperationKHR::from_raw(305398016_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::AllocationCallbacks,
		)
		.unwrap();
		vk::Device::destroy_deferred_operation_khr(
			&fixture.device,
			vk::DeferredOperationKHR::from_raw(305398016_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::AllocationCallbacks,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_deferred_operation_max_concurrency_khr_signature_and_missing_command() {
	type Signature = unsafe fn(&vk::Device, vk::DeferredOperationKHR) -> Result<u32, CallError>;
	let _: Signature = vk::get_deferred_operation_max_concurrency_khr;
	let _: Signature = vk::Device::get_deferred_operation_max_concurrency_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_deferred_operation_max_concurrency_khr(
				&fixture.device,
				std::mem::zeroed::<vk::DeferredOperationKHR>()
			),
			Err(CallError::MissingCommand(
				"vkGetDeferredOperationMaxConcurrencyKHR"
			))
		));
		assert!(matches!(
			fixture
				.device
				.get_deferred_operation_max_concurrency_khr(std::mem::zeroed::<vk::DeferredOperationKHR>()),
			Err(CallError::MissingCommand(
				"vkGetDeferredOperationMaxConcurrencyKHR"
			))
		));
	}
}

#[test]
fn get_deferred_operation_max_concurrency_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::DeviceHandle, arg_1: vk::DeferredOperationKHR) -> u32 {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::DeferredOperationKHR::from_raw(305398016_u64 as _)),
		);
		0xfedc_ba98_7654_3210_u64 as u32
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetDeferredOperationMaxConcurrencyKHR = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetDeferredOperationMaxConcurrencyKHR,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkGetDeferredOperationMaxConcurrencyKHR", erased);
		let resolutions = Fixture::query_count();
		assert_eq!(
			vk::get_deferred_operation_max_concurrency_khr(
				&fixture.device,
				vk::DeferredOperationKHR::from_raw(305398016_u64 as _)
			)
			.unwrap(),
			0xfedc_ba98_7654_3210_u64 as u32
		);
		assert_eq!(
			vk::Device::get_deferred_operation_max_concurrency_khr(
				&fixture.device,
				vk::DeferredOperationKHR::from_raw(305398016_u64 as _)
			)
			.unwrap(),
			0xfedc_ba98_7654_3210_u64 as u32
		);
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_deferred_operation_result_khr_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, vk::DeferredOperationKHR) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_deferred_operation_result_khr;
	let _: Signature = vk::Device::get_deferred_operation_result_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_deferred_operation_result_khr(
				&fixture.device,
				std::mem::zeroed::<vk::DeferredOperationKHR>()
			),
			Err(CallError::MissingCommand("vkGetDeferredOperationResultKHR"))
		));
		assert!(matches!(
			fixture
				.device
				.get_deferred_operation_result_khr(std::mem::zeroed::<vk::DeferredOperationKHR>()),
			Err(CallError::MissingCommand("vkGetDeferredOperationResultKHR"))
		));
	}
}

#[test]
fn get_deferred_operation_result_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::DeferredOperationKHR,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::DeferredOperationKHR::from_raw(305398016_u64 as _)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetDeferredOperationResultKHR = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkGetDeferredOperationResultKHR, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkGetDeferredOperationResultKHR", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_deferred_operation_result_khr(
					&fixture.device,
					vk::DeferredOperationKHR::from_raw(305398016_u64 as _)
				),
				expected
			);
			assert_eq!(
				vk::Device::get_deferred_operation_result_khr(
					&fixture.device,
					vk::DeferredOperationKHR::from_raw(305398016_u64 as _)
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn deferred_operation_join_khr_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, vk::DeferredOperationKHR) -> Result<vk::Result, CallError>;
	let _: Signature = vk::deferred_operation_join_khr;
	let _: Signature = vk::Device::deferred_operation_join_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::deferred_operation_join_khr(
				&fixture.device,
				std::mem::zeroed::<vk::DeferredOperationKHR>()
			),
			Err(CallError::MissingCommand("vkDeferredOperationJoinKHR"))
		));
		assert!(matches!(
			fixture
				.device
				.deferred_operation_join_khr(std::mem::zeroed::<vk::DeferredOperationKHR>()),
			Err(CallError::MissingCommand("vkDeferredOperationJoinKHR"))
		));
	}
}

#[test]
fn deferred_operation_join_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::DeferredOperationKHR,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::DeferredOperationKHR::from_raw(305398016_u64 as _)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkDeferredOperationJoinKHR = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkDeferredOperationJoinKHR, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkDeferredOperationJoinKHR", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::deferred_operation_join_khr(
					&fixture.device,
					vk::DeferredOperationKHR::from_raw(305398016_u64 as _)
				),
				expected
			);
			assert_eq!(
				vk::Device::deferred_operation_join_khr(
					&fixture.device,
					vk::DeferredOperationKHR::from_raw(305398016_u64 as _)
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_pipeline_indirect_memory_requirements_nv_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::ComputePipelineCreateInfo<'_>,
		*mut vk::MemoryRequirements2<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::get_pipeline_indirect_memory_requirements_nv;
	let _: Signature = vk::Device::get_pipeline_indirect_memory_requirements_nv;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_pipeline_indirect_memory_requirements_nv(
				&fixture.device,
				std::mem::zeroed::<*const vk::ComputePipelineCreateInfo<'_>>(),
				std::mem::zeroed::<*mut vk::MemoryRequirements2<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetPipelineIndirectMemoryRequirementsNV"
			))
		));
		assert!(matches!(
			fixture.device.get_pipeline_indirect_memory_requirements_nv(
				std::mem::zeroed::<*const vk::ComputePipelineCreateInfo<'_>>(),
				std::mem::zeroed::<*mut vk::MemoryRequirements2<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetPipelineIndirectMemoryRequirementsNV"
			))
		));
	}
}

#[test]
fn get_pipeline_indirect_memory_requirements_nv_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::ComputePipelineCreateInfo<'_>,
		arg_2: *mut vk::MemoryRequirements2<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::ComputePipelineCreateInfo<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::MemoryRequirements2<'_>,
				)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetPipelineIndirectMemoryRequirementsNV = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetPipelineIndirectMemoryRequirementsNV,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkGetPipelineIndirectMemoryRequirementsNV", erased);
		let resolutions = Fixture::query_count();
		vk::get_pipeline_indirect_memory_requirements_nv(
			&fixture.device,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::ComputePipelineCreateInfo<'_>,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *mut vk::MemoryRequirements2<'_>,
		)
		.unwrap();
		vk::Device::get_pipeline_indirect_memory_requirements_nv(
			&fixture.device,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::ComputePipelineCreateInfo<'_>,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *mut vk::MemoryRequirements2<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_pipeline_indirect_device_address_nv_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::PipelineIndirectDeviceAddressInfoNV<'_>,
	) -> Result<vk::DeviceAddress, CallError>;
	let _: Signature = vk::get_pipeline_indirect_device_address_nv;
	let _: Signature = vk::Device::get_pipeline_indirect_device_address_nv;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_pipeline_indirect_device_address_nv(
				&fixture.device,
				std::mem::zeroed::<*const vk::PipelineIndirectDeviceAddressInfoNV<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetPipelineIndirectDeviceAddressNV"
			))
		));
		assert!(matches!(
			fixture
				.device
				.get_pipeline_indirect_device_address_nv(std::mem::zeroed::<
					*const vk::PipelineIndirectDeviceAddressInfoNV<'_>,
				>()),
			Err(CallError::MissingCommand(
				"vkGetPipelineIndirectDeviceAddressNV"
			))
		));
	}
}

#[test]
fn get_pipeline_indirect_device_address_nv_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::PipelineIndirectDeviceAddressInfoNV<'_>,
	) -> vk::DeviceAddress {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::PipelineIndirectDeviceAddressInfoNV<'_>,
					)),
		);
		0xfedc_ba98_7654_3210_u64 as vk::DeviceAddress
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetPipelineIndirectDeviceAddressNV = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetPipelineIndirectDeviceAddressNV,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkGetPipelineIndirectDeviceAddressNV", erased);
		let resolutions = Fixture::query_count();
		assert_eq!(
			vk::get_pipeline_indirect_device_address_nv(
				&fixture.device,
				std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
					as *const vk::PipelineIndirectDeviceAddressInfoNV<'_>
			)
			.unwrap(),
			0xfedc_ba98_7654_3210_u64 as vk::DeviceAddress
		);
		assert_eq!(
			vk::Device::get_pipeline_indirect_device_address_nv(
				&fixture.device,
				std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
					as *const vk::PipelineIndirectDeviceAddressInfoNV<'_>
			)
			.unwrap(),
			0xfedc_ba98_7654_3210_u64 as vk::DeviceAddress
		);
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn anti_lag_update_amd_signature_and_missing_command() {
	type Signature = unsafe fn(&vk::Device, *const vk::AntiLagDataAMD<'_>) -> Result<(), CallError>;
	let _: Signature = vk::anti_lag_update_amd;
	let _: Signature = vk::Device::anti_lag_update_amd;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::anti_lag_update_amd(
				&fixture.device,
				std::mem::zeroed::<*const vk::AntiLagDataAMD<'_>>()
			),
			Err(CallError::MissingCommand("vkAntiLagUpdateAMD"))
		));
		assert!(matches!(
			fixture
				.device
				.anti_lag_update_amd(std::mem::zeroed::<*const vk::AntiLagDataAMD<'_>>()),
			Err(CallError::MissingCommand("vkAntiLagUpdateAMD"))
		));
	}
}

#[test]
fn anti_lag_update_amd_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::DeviceHandle, arg_1: *const vk::AntiLagDataAMD<'_>) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::AntiLagDataAMD<'_>,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkAntiLagUpdateAMD = Some(mock);
		let erased = std::mem::transmute::<vk::PFN_vkAntiLagUpdateAMD, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkAntiLagUpdateAMD", erased);
		let resolutions = Fixture::query_count();
		vk::anti_lag_update_amd(
			&fixture.device,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::AntiLagDataAMD<'_>,
		)
		.unwrap();
		vk::Device::anti_lag_update_amd(
			&fixture.device,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::AntiLagDataAMD<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_set_cull_mode_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, vk::CommandBuffer, vk::CullModeFlags) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_cull_mode;
	let _: Signature = vk::Device::cmd_set_cull_mode;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_cull_mode(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::CullModeFlags>()
			),
			Err(CallError::MissingCommand("vkCmdSetCullMode"))
		));
		assert!(matches!(
			fixture.device.cmd_set_cull_mode(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::CullModeFlags>()
			),
			Err(CallError::MissingCommand("vkCmdSetCullMode"))
		));
	}
}

#[test]
fn cmd_set_cull_mode_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::CommandBuffer, arg_1: vk::CullModeFlags) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == vk::CullModeFlags::from_raw(305398016_u64 as _)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdSetCullMode = Some(mock);
		let erased = std::mem::transmute::<vk::PFN_vkCmdSetCullMode, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdSetCullMode", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_set_cull_mode(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::CullModeFlags::from_raw(305398016_u64 as _),
		)
		.unwrap();
		vk::Device::cmd_set_cull_mode(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::CullModeFlags::from_raw(305398016_u64 as _),
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_set_cull_mode_ext_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, vk::CommandBuffer, vk::CullModeFlags) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_cull_mode_ext;
	let _: Signature = vk::Device::cmd_set_cull_mode_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_cull_mode_ext(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::CullModeFlags>()
			),
			Err(CallError::MissingCommand("vkCmdSetCullModeEXT"))
		));
		assert!(matches!(
			fixture.device.cmd_set_cull_mode_ext(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::CullModeFlags>()
			),
			Err(CallError::MissingCommand("vkCmdSetCullModeEXT"))
		));
	}
}

#[test]
fn cmd_set_cull_mode_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::CommandBuffer, arg_1: vk::CullModeFlags) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == vk::CullModeFlags::from_raw(305398016_u64 as _)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdSetCullModeEXT = Some(mock);
		let erased = std::mem::transmute::<vk::PFN_vkCmdSetCullModeEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdSetCullModeEXT", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_set_cull_mode_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::CullModeFlags::from_raw(305398016_u64 as _),
		)
		.unwrap();
		vk::Device::cmd_set_cull_mode_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::CullModeFlags::from_raw(305398016_u64 as _),
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_set_front_face_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, vk::CommandBuffer, vk::FrontFace) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_front_face;
	let _: Signature = vk::Device::cmd_set_front_face;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_front_face(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::FrontFace>()
			),
			Err(CallError::MissingCommand("vkCmdSetFrontFace"))
		));
		assert!(matches!(
			fixture.device.cmd_set_front_face(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::FrontFace>()
			),
			Err(CallError::MissingCommand("vkCmdSetFrontFace"))
		));
	}
}

#[test]
fn cmd_set_front_face_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::CommandBuffer, arg_1: vk::FrontFace) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == vk::FrontFace::from_raw(305398016_u64 as _)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdSetFrontFace = Some(mock);
		let erased = std::mem::transmute::<vk::PFN_vkCmdSetFrontFace, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdSetFrontFace", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_set_front_face(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::FrontFace::from_raw(305398016_u64 as _),
		)
		.unwrap();
		vk::Device::cmd_set_front_face(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::FrontFace::from_raw(305398016_u64 as _),
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_set_front_face_ext_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, vk::CommandBuffer, vk::FrontFace) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_front_face_ext;
	let _: Signature = vk::Device::cmd_set_front_face_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_front_face_ext(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::FrontFace>()
			),
			Err(CallError::MissingCommand("vkCmdSetFrontFaceEXT"))
		));
		assert!(matches!(
			fixture.device.cmd_set_front_face_ext(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::FrontFace>()
			),
			Err(CallError::MissingCommand("vkCmdSetFrontFaceEXT"))
		));
	}
}

#[test]
fn cmd_set_front_face_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::CommandBuffer, arg_1: vk::FrontFace) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == vk::FrontFace::from_raw(305398016_u64 as _)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdSetFrontFaceEXT = Some(mock);
		let erased = std::mem::transmute::<vk::PFN_vkCmdSetFrontFaceEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdSetFrontFaceEXT", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_set_front_face_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::FrontFace::from_raw(305398016_u64 as _),
		)
		.unwrap();
		vk::Device::cmd_set_front_face_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::FrontFace::from_raw(305398016_u64 as _),
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_set_primitive_topology_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, vk::CommandBuffer, vk::PrimitiveTopology) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_primitive_topology;
	let _: Signature = vk::Device::cmd_set_primitive_topology;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_primitive_topology(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::PrimitiveTopology>()
			),
			Err(CallError::MissingCommand("vkCmdSetPrimitiveTopology"))
		));
		assert!(matches!(
			fixture.device.cmd_set_primitive_topology(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::PrimitiveTopology>()
			),
			Err(CallError::MissingCommand("vkCmdSetPrimitiveTopology"))
		));
	}
}

#[test]
fn cmd_set_primitive_topology_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::CommandBuffer, arg_1: vk::PrimitiveTopology) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == vk::PrimitiveTopology::from_raw(305398016_u64 as _)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdSetPrimitiveTopology = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdSetPrimitiveTopology, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdSetPrimitiveTopology", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_set_primitive_topology(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::PrimitiveTopology::from_raw(305398016_u64 as _),
		)
		.unwrap();
		vk::Device::cmd_set_primitive_topology(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::PrimitiveTopology::from_raw(305398016_u64 as _),
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_set_primitive_topology_ext_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, vk::CommandBuffer, vk::PrimitiveTopology) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_primitive_topology_ext;
	let _: Signature = vk::Device::cmd_set_primitive_topology_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_primitive_topology_ext(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::PrimitiveTopology>()
			),
			Err(CallError::MissingCommand("vkCmdSetPrimitiveTopologyEXT"))
		));
		assert!(matches!(
			fixture.device.cmd_set_primitive_topology_ext(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::PrimitiveTopology>()
			),
			Err(CallError::MissingCommand("vkCmdSetPrimitiveTopologyEXT"))
		));
	}
}

#[test]
fn cmd_set_primitive_topology_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::CommandBuffer, arg_1: vk::PrimitiveTopology) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == vk::PrimitiveTopology::from_raw(305398016_u64 as _)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdSetPrimitiveTopologyEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdSetPrimitiveTopologyEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdSetPrimitiveTopologyEXT", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_set_primitive_topology_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::PrimitiveTopology::from_raw(305398016_u64 as _),
		)
		.unwrap();
		vk::Device::cmd_set_primitive_topology_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::PrimitiveTopology::from_raw(305398016_u64 as _),
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_set_viewport_with_count_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, vk::CommandBuffer, u32, *const vk::Viewport) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_viewport_with_count;
	let _: Signature = vk::Device::cmd_set_viewport_with_count;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_viewport_with_count(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::Viewport>()
			),
			Err(CallError::MissingCommand("vkCmdSetViewportWithCount"))
		));
		assert!(matches!(
			fixture.device.cmd_set_viewport_with_count(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::Viewport>()
			),
			Err(CallError::MissingCommand("vkCmdSetViewportWithCount"))
		));
	}
}

#[test]
fn cmd_set_viewport_with_count_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::CommandBuffer, arg_1: u32, arg_2: *const vk::Viewport) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == Default::default()
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *const vk::Viewport,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdSetViewportWithCount = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdSetViewportWithCount, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdSetViewportWithCount", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_set_viewport_with_count(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *const vk::Viewport,
		)
		.unwrap();
		vk::Device::cmd_set_viewport_with_count(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *const vk::Viewport,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_set_viewport_with_count_ext_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, vk::CommandBuffer, u32, *const vk::Viewport) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_viewport_with_count_ext;
	let _: Signature = vk::Device::cmd_set_viewport_with_count_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_viewport_with_count_ext(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::Viewport>()
			),
			Err(CallError::MissingCommand("vkCmdSetViewportWithCountEXT"))
		));
		assert!(matches!(
			fixture.device.cmd_set_viewport_with_count_ext(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::Viewport>()
			),
			Err(CallError::MissingCommand("vkCmdSetViewportWithCountEXT"))
		));
	}
}

#[test]
fn cmd_set_viewport_with_count_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::CommandBuffer, arg_1: u32, arg_2: *const vk::Viewport) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == Default::default()
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *const vk::Viewport,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdSetViewportWithCountEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdSetViewportWithCountEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdSetViewportWithCountEXT", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_set_viewport_with_count_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *const vk::Viewport,
		)
		.unwrap();
		vk::Device::cmd_set_viewport_with_count_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *const vk::Viewport,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_set_scissor_with_count_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, vk::CommandBuffer, u32, *const vk::Rect2D) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_scissor_with_count;
	let _: Signature = vk::Device::cmd_set_scissor_with_count;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_scissor_with_count(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::Rect2D>()
			),
			Err(CallError::MissingCommand("vkCmdSetScissorWithCount"))
		));
		assert!(matches!(
			fixture.device.cmd_set_scissor_with_count(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::Rect2D>()
			),
			Err(CallError::MissingCommand("vkCmdSetScissorWithCount"))
		));
	}
}

#[test]
fn cmd_set_scissor_with_count_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::CommandBuffer, arg_1: u32, arg_2: *const vk::Rect2D) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == Default::default()
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *const vk::Rect2D,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdSetScissorWithCount = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdSetScissorWithCount, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdSetScissorWithCount", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_set_scissor_with_count(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *const vk::Rect2D,
		)
		.unwrap();
		vk::Device::cmd_set_scissor_with_count(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *const vk::Rect2D,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_set_scissor_with_count_ext_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, vk::CommandBuffer, u32, *const vk::Rect2D) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_scissor_with_count_ext;
	let _: Signature = vk::Device::cmd_set_scissor_with_count_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_scissor_with_count_ext(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::Rect2D>()
			),
			Err(CallError::MissingCommand("vkCmdSetScissorWithCountEXT"))
		));
		assert!(matches!(
			fixture.device.cmd_set_scissor_with_count_ext(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::Rect2D>()
			),
			Err(CallError::MissingCommand("vkCmdSetScissorWithCountEXT"))
		));
	}
}

#[test]
fn cmd_set_scissor_with_count_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::CommandBuffer, arg_1: u32, arg_2: *const vk::Rect2D) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == Default::default()
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *const vk::Rect2D,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdSetScissorWithCountEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdSetScissorWithCountEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdSetScissorWithCountEXT", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_set_scissor_with_count_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *const vk::Rect2D,
		)
		.unwrap();
		vk::Device::cmd_set_scissor_with_count_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *const vk::Rect2D,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_bind_index_buffer2_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		vk::Buffer,
		vk::DeviceSize,
		vk::DeviceSize,
		vk::IndexType,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_bind_index_buffer2;
	let _: Signature = vk::Device::cmd_bind_index_buffer2;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_bind_index_buffer2(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::Buffer>(),
				std::mem::zeroed::<vk::DeviceSize>(),
				std::mem::zeroed::<vk::DeviceSize>(),
				std::mem::zeroed::<vk::IndexType>()
			),
			Err(CallError::MissingCommand("vkCmdBindIndexBuffer2"))
		));
		assert!(matches!(
			fixture.device.cmd_bind_index_buffer2(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::Buffer>(),
				std::mem::zeroed::<vk::DeviceSize>(),
				std::mem::zeroed::<vk::DeviceSize>(),
				std::mem::zeroed::<vk::IndexType>()
			),
			Err(CallError::MissingCommand("vkCmdBindIndexBuffer2"))
		));
	}
}

#[test]
fn cmd_bind_index_buffer2_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: vk::Buffer,
		arg_2: vk::DeviceSize,
		arg_3: vk::DeviceSize,
		arg_4: vk::IndexType,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == vk::Buffer::from_raw(305398016_u64 as _)
					&& arg_2 == 305398272_u64 as vk::DeviceSize
					&& arg_3 == 305398528_u64 as vk::DeviceSize
					&& arg_4 == vk::IndexType::from_raw(305398784_u64 as _)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdBindIndexBuffer2 = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdBindIndexBuffer2, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdBindIndexBuffer2", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_bind_index_buffer2(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::Buffer::from_raw(305398016_u64 as _),
			305398272_u64 as vk::DeviceSize,
			305398528_u64 as vk::DeviceSize,
			vk::IndexType::from_raw(305398784_u64 as _),
		)
		.unwrap();
		vk::Device::cmd_bind_index_buffer2(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::Buffer::from_raw(305398016_u64 as _),
			305398272_u64 as vk::DeviceSize,
			305398528_u64 as vk::DeviceSize,
			vk::IndexType::from_raw(305398784_u64 as _),
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_bind_index_buffer2_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		vk::Buffer,
		vk::DeviceSize,
		vk::DeviceSize,
		vk::IndexType,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_bind_index_buffer2_khr;
	let _: Signature = vk::Device::cmd_bind_index_buffer2_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_bind_index_buffer2_khr(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::Buffer>(),
				std::mem::zeroed::<vk::DeviceSize>(),
				std::mem::zeroed::<vk::DeviceSize>(),
				std::mem::zeroed::<vk::IndexType>()
			),
			Err(CallError::MissingCommand("vkCmdBindIndexBuffer2KHR"))
		));
		assert!(matches!(
			fixture.device.cmd_bind_index_buffer2_khr(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::Buffer>(),
				std::mem::zeroed::<vk::DeviceSize>(),
				std::mem::zeroed::<vk::DeviceSize>(),
				std::mem::zeroed::<vk::IndexType>()
			),
			Err(CallError::MissingCommand("vkCmdBindIndexBuffer2KHR"))
		));
	}
}

#[test]
fn cmd_bind_index_buffer2_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: vk::Buffer,
		arg_2: vk::DeviceSize,
		arg_3: vk::DeviceSize,
		arg_4: vk::IndexType,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == vk::Buffer::from_raw(305398016_u64 as _)
					&& arg_2 == 305398272_u64 as vk::DeviceSize
					&& arg_3 == 305398528_u64 as vk::DeviceSize
					&& arg_4 == vk::IndexType::from_raw(305398784_u64 as _)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdBindIndexBuffer2KHR = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdBindIndexBuffer2KHR, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdBindIndexBuffer2KHR", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_bind_index_buffer2_khr(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::Buffer::from_raw(305398016_u64 as _),
			305398272_u64 as vk::DeviceSize,
			305398528_u64 as vk::DeviceSize,
			vk::IndexType::from_raw(305398784_u64 as _),
		)
		.unwrap();
		vk::Device::cmd_bind_index_buffer2_khr(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::Buffer::from_raw(305398016_u64 as _),
			305398272_u64 as vk::DeviceSize,
			305398528_u64 as vk::DeviceSize,
			vk::IndexType::from_raw(305398784_u64 as _),
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_bind_vertex_buffers2_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		u32,
		u32,
		*const vk::Buffer,
		*const vk::DeviceSize,
		*const vk::DeviceSize,
		*const vk::DeviceSize,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_bind_vertex_buffers2;
	let _: Signature = vk::Device::cmd_bind_vertex_buffers2;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_bind_vertex_buffers2(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::Buffer>(),
				std::mem::zeroed::<*const vk::DeviceSize>(),
				std::mem::zeroed::<*const vk::DeviceSize>(),
				std::mem::zeroed::<*const vk::DeviceSize>()
			),
			Err(CallError::MissingCommand("vkCmdBindVertexBuffers2"))
		));
		assert!(matches!(
			fixture.device.cmd_bind_vertex_buffers2(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::Buffer>(),
				std::mem::zeroed::<*const vk::DeviceSize>(),
				std::mem::zeroed::<*const vk::DeviceSize>(),
				std::mem::zeroed::<*const vk::DeviceSize>()
			),
			Err(CallError::MissingCommand("vkCmdBindVertexBuffers2"))
		));
	}
}

#[test]
fn cmd_bind_vertex_buffers2_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: u32,
		arg_2: u32,
		arg_3: *const vk::Buffer,
		arg_4: *const vk::DeviceSize,
		arg_5: *const vk::DeviceSize,
		arg_6: *const vk::DeviceSize,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == Default::default()
					&& arg_2 == Default::default()
					&& std::ptr::eq(
						arg_3,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *const vk::Buffer,
					) && std::ptr::eq(
					arg_4,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784) as *const vk::DeviceSize,
				) && std::ptr::eq(
					arg_5,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305399040) as *const vk::DeviceSize,
				) && std::ptr::eq(
					arg_6,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305399296) as *const vk::DeviceSize,
				)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdBindVertexBuffers2 = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdBindVertexBuffers2, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdBindVertexBuffers2", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_bind_vertex_buffers2(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *const vk::Buffer,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784) as *const vk::DeviceSize,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305399040) as *const vk::DeviceSize,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305399296) as *const vk::DeviceSize,
		)
		.unwrap();
		vk::Device::cmd_bind_vertex_buffers2(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *const vk::Buffer,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784) as *const vk::DeviceSize,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305399040) as *const vk::DeviceSize,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305399296) as *const vk::DeviceSize,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_bind_vertex_buffers2_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		u32,
		u32,
		*const vk::Buffer,
		*const vk::DeviceSize,
		*const vk::DeviceSize,
		*const vk::DeviceSize,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_bind_vertex_buffers2_ext;
	let _: Signature = vk::Device::cmd_bind_vertex_buffers2_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_bind_vertex_buffers2_ext(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::Buffer>(),
				std::mem::zeroed::<*const vk::DeviceSize>(),
				std::mem::zeroed::<*const vk::DeviceSize>(),
				std::mem::zeroed::<*const vk::DeviceSize>()
			),
			Err(CallError::MissingCommand("vkCmdBindVertexBuffers2EXT"))
		));
		assert!(matches!(
			fixture.device.cmd_bind_vertex_buffers2_ext(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::Buffer>(),
				std::mem::zeroed::<*const vk::DeviceSize>(),
				std::mem::zeroed::<*const vk::DeviceSize>(),
				std::mem::zeroed::<*const vk::DeviceSize>()
			),
			Err(CallError::MissingCommand("vkCmdBindVertexBuffers2EXT"))
		));
	}
}

#[test]
fn cmd_bind_vertex_buffers2_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: u32,
		arg_2: u32,
		arg_3: *const vk::Buffer,
		arg_4: *const vk::DeviceSize,
		arg_5: *const vk::DeviceSize,
		arg_6: *const vk::DeviceSize,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == Default::default()
					&& arg_2 == Default::default()
					&& std::ptr::eq(
						arg_3,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *const vk::Buffer,
					) && std::ptr::eq(
					arg_4,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784) as *const vk::DeviceSize,
				) && std::ptr::eq(
					arg_5,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305399040) as *const vk::DeviceSize,
				) && std::ptr::eq(
					arg_6,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305399296) as *const vk::DeviceSize,
				)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdBindVertexBuffers2EXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdBindVertexBuffers2EXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdBindVertexBuffers2EXT", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_bind_vertex_buffers2_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *const vk::Buffer,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784) as *const vk::DeviceSize,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305399040) as *const vk::DeviceSize,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305399296) as *const vk::DeviceSize,
		)
		.unwrap();
		vk::Device::cmd_bind_vertex_buffers2_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *const vk::Buffer,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784) as *const vk::DeviceSize,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305399040) as *const vk::DeviceSize,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305399296) as *const vk::DeviceSize,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_set_depth_test_enable_signature_and_missing_command() {
	type Signature = unsafe fn(&vk::Device, vk::CommandBuffer, vk::Bool32) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_depth_test_enable;
	let _: Signature = vk::Device::cmd_set_depth_test_enable;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_depth_test_enable(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::Bool32>()
			),
			Err(CallError::MissingCommand("vkCmdSetDepthTestEnable"))
		));
		assert!(matches!(
			fixture.device.cmd_set_depth_test_enable(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::Bool32>()
			),
			Err(CallError::MissingCommand("vkCmdSetDepthTestEnable"))
		));
	}
}

#[test]
fn cmd_set_depth_test_enable_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::CommandBuffer, arg_1: vk::Bool32) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == 305398016_u64 as vk::Bool32),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdSetDepthTestEnable = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdSetDepthTestEnable, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdSetDepthTestEnable", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_set_depth_test_enable(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			305398016_u64 as vk::Bool32,
		)
		.unwrap();
		vk::Device::cmd_set_depth_test_enable(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			305398016_u64 as vk::Bool32,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_set_depth_test_enable_ext_signature_and_missing_command() {
	type Signature = unsafe fn(&vk::Device, vk::CommandBuffer, vk::Bool32) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_depth_test_enable_ext;
	let _: Signature = vk::Device::cmd_set_depth_test_enable_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_depth_test_enable_ext(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::Bool32>()
			),
			Err(CallError::MissingCommand("vkCmdSetDepthTestEnableEXT"))
		));
		assert!(matches!(
			fixture.device.cmd_set_depth_test_enable_ext(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::Bool32>()
			),
			Err(CallError::MissingCommand("vkCmdSetDepthTestEnableEXT"))
		));
	}
}

#[test]
fn cmd_set_depth_test_enable_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::CommandBuffer, arg_1: vk::Bool32) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == 305398016_u64 as vk::Bool32),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdSetDepthTestEnableEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdSetDepthTestEnableEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdSetDepthTestEnableEXT", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_set_depth_test_enable_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			305398016_u64 as vk::Bool32,
		)
		.unwrap();
		vk::Device::cmd_set_depth_test_enable_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			305398016_u64 as vk::Bool32,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_set_depth_write_enable_signature_and_missing_command() {
	type Signature = unsafe fn(&vk::Device, vk::CommandBuffer, vk::Bool32) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_depth_write_enable;
	let _: Signature = vk::Device::cmd_set_depth_write_enable;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_depth_write_enable(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::Bool32>()
			),
			Err(CallError::MissingCommand("vkCmdSetDepthWriteEnable"))
		));
		assert!(matches!(
			fixture.device.cmd_set_depth_write_enable(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::Bool32>()
			),
			Err(CallError::MissingCommand("vkCmdSetDepthWriteEnable"))
		));
	}
}

#[test]
fn cmd_set_depth_write_enable_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::CommandBuffer, arg_1: vk::Bool32) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == 305398016_u64 as vk::Bool32),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdSetDepthWriteEnable = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdSetDepthWriteEnable, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdSetDepthWriteEnable", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_set_depth_write_enable(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			305398016_u64 as vk::Bool32,
		)
		.unwrap();
		vk::Device::cmd_set_depth_write_enable(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			305398016_u64 as vk::Bool32,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_set_depth_write_enable_ext_signature_and_missing_command() {
	type Signature = unsafe fn(&vk::Device, vk::CommandBuffer, vk::Bool32) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_depth_write_enable_ext;
	let _: Signature = vk::Device::cmd_set_depth_write_enable_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_depth_write_enable_ext(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::Bool32>()
			),
			Err(CallError::MissingCommand("vkCmdSetDepthWriteEnableEXT"))
		));
		assert!(matches!(
			fixture.device.cmd_set_depth_write_enable_ext(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::Bool32>()
			),
			Err(CallError::MissingCommand("vkCmdSetDepthWriteEnableEXT"))
		));
	}
}

#[test]
fn cmd_set_depth_write_enable_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::CommandBuffer, arg_1: vk::Bool32) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == 305398016_u64 as vk::Bool32),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdSetDepthWriteEnableEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdSetDepthWriteEnableEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdSetDepthWriteEnableEXT", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_set_depth_write_enable_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			305398016_u64 as vk::Bool32,
		)
		.unwrap();
		vk::Device::cmd_set_depth_write_enable_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			305398016_u64 as vk::Bool32,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_set_depth_compare_op_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, vk::CommandBuffer, vk::CompareOp) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_depth_compare_op;
	let _: Signature = vk::Device::cmd_set_depth_compare_op;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_depth_compare_op(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::CompareOp>()
			),
			Err(CallError::MissingCommand("vkCmdSetDepthCompareOp"))
		));
		assert!(matches!(
			fixture.device.cmd_set_depth_compare_op(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::CompareOp>()
			),
			Err(CallError::MissingCommand("vkCmdSetDepthCompareOp"))
		));
	}
}

#[test]
fn cmd_set_depth_compare_op_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::CommandBuffer, arg_1: vk::CompareOp) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == vk::CompareOp::from_raw(305398016_u64 as _)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdSetDepthCompareOp = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdSetDepthCompareOp, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdSetDepthCompareOp", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_set_depth_compare_op(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::CompareOp::from_raw(305398016_u64 as _),
		)
		.unwrap();
		vk::Device::cmd_set_depth_compare_op(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::CompareOp::from_raw(305398016_u64 as _),
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_set_depth_compare_op_ext_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, vk::CommandBuffer, vk::CompareOp) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_depth_compare_op_ext;
	let _: Signature = vk::Device::cmd_set_depth_compare_op_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_depth_compare_op_ext(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::CompareOp>()
			),
			Err(CallError::MissingCommand("vkCmdSetDepthCompareOpEXT"))
		));
		assert!(matches!(
			fixture.device.cmd_set_depth_compare_op_ext(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::CompareOp>()
			),
			Err(CallError::MissingCommand("vkCmdSetDepthCompareOpEXT"))
		));
	}
}

#[test]
fn cmd_set_depth_compare_op_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::CommandBuffer, arg_1: vk::CompareOp) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == vk::CompareOp::from_raw(305398016_u64 as _)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdSetDepthCompareOpEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdSetDepthCompareOpEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdSetDepthCompareOpEXT", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_set_depth_compare_op_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::CompareOp::from_raw(305398016_u64 as _),
		)
		.unwrap();
		vk::Device::cmd_set_depth_compare_op_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::CompareOp::from_raw(305398016_u64 as _),
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_set_depth_bounds_test_enable_signature_and_missing_command() {
	type Signature = unsafe fn(&vk::Device, vk::CommandBuffer, vk::Bool32) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_depth_bounds_test_enable;
	let _: Signature = vk::Device::cmd_set_depth_bounds_test_enable;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_depth_bounds_test_enable(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::Bool32>()
			),
			Err(CallError::MissingCommand("vkCmdSetDepthBoundsTestEnable"))
		));
		assert!(matches!(
			fixture.device.cmd_set_depth_bounds_test_enable(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::Bool32>()
			),
			Err(CallError::MissingCommand("vkCmdSetDepthBoundsTestEnable"))
		));
	}
}

#[test]
fn cmd_set_depth_bounds_test_enable_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::CommandBuffer, arg_1: vk::Bool32) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == 305398016_u64 as vk::Bool32),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdSetDepthBoundsTestEnable = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdSetDepthBoundsTestEnable, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdSetDepthBoundsTestEnable", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_set_depth_bounds_test_enable(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			305398016_u64 as vk::Bool32,
		)
		.unwrap();
		vk::Device::cmd_set_depth_bounds_test_enable(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			305398016_u64 as vk::Bool32,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_set_depth_bounds_test_enable_ext_signature_and_missing_command() {
	type Signature = unsafe fn(&vk::Device, vk::CommandBuffer, vk::Bool32) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_depth_bounds_test_enable_ext;
	let _: Signature = vk::Device::cmd_set_depth_bounds_test_enable_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_depth_bounds_test_enable_ext(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::Bool32>()
			),
			Err(CallError::MissingCommand(
				"vkCmdSetDepthBoundsTestEnableEXT"
			))
		));
		assert!(matches!(
			fixture.device.cmd_set_depth_bounds_test_enable_ext(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::Bool32>()
			),
			Err(CallError::MissingCommand(
				"vkCmdSetDepthBoundsTestEnableEXT"
			))
		));
	}
}

#[test]
fn cmd_set_depth_bounds_test_enable_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::CommandBuffer, arg_1: vk::Bool32) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == 305398016_u64 as vk::Bool32),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdSetDepthBoundsTestEnableEXT = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkCmdSetDepthBoundsTestEnableEXT,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdSetDepthBoundsTestEnableEXT", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_set_depth_bounds_test_enable_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			305398016_u64 as vk::Bool32,
		)
		.unwrap();
		vk::Device::cmd_set_depth_bounds_test_enable_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			305398016_u64 as vk::Bool32,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_set_stencil_test_enable_signature_and_missing_command() {
	type Signature = unsafe fn(&vk::Device, vk::CommandBuffer, vk::Bool32) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_stencil_test_enable;
	let _: Signature = vk::Device::cmd_set_stencil_test_enable;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_stencil_test_enable(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::Bool32>()
			),
			Err(CallError::MissingCommand("vkCmdSetStencilTestEnable"))
		));
		assert!(matches!(
			fixture.device.cmd_set_stencil_test_enable(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::Bool32>()
			),
			Err(CallError::MissingCommand("vkCmdSetStencilTestEnable"))
		));
	}
}

#[test]
fn cmd_set_stencil_test_enable_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::CommandBuffer, arg_1: vk::Bool32) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == 305398016_u64 as vk::Bool32),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdSetStencilTestEnable = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdSetStencilTestEnable, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdSetStencilTestEnable", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_set_stencil_test_enable(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			305398016_u64 as vk::Bool32,
		)
		.unwrap();
		vk::Device::cmd_set_stencil_test_enable(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			305398016_u64 as vk::Bool32,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_set_stencil_test_enable_ext_signature_and_missing_command() {
	type Signature = unsafe fn(&vk::Device, vk::CommandBuffer, vk::Bool32) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_stencil_test_enable_ext;
	let _: Signature = vk::Device::cmd_set_stencil_test_enable_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_stencil_test_enable_ext(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::Bool32>()
			),
			Err(CallError::MissingCommand("vkCmdSetStencilTestEnableEXT"))
		));
		assert!(matches!(
			fixture.device.cmd_set_stencil_test_enable_ext(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::Bool32>()
			),
			Err(CallError::MissingCommand("vkCmdSetStencilTestEnableEXT"))
		));
	}
}

#[test]
fn cmd_set_stencil_test_enable_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::CommandBuffer, arg_1: vk::Bool32) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == 305398016_u64 as vk::Bool32),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdSetStencilTestEnableEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdSetStencilTestEnableEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdSetStencilTestEnableEXT", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_set_stencil_test_enable_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			305398016_u64 as vk::Bool32,
		)
		.unwrap();
		vk::Device::cmd_set_stencil_test_enable_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			305398016_u64 as vk::Bool32,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_set_stencil_op_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		vk::StencilFaceFlags,
		vk::StencilOp,
		vk::StencilOp,
		vk::StencilOp,
		vk::CompareOp,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_stencil_op;
	let _: Signature = vk::Device::cmd_set_stencil_op;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_stencil_op(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::StencilFaceFlags>(),
				std::mem::zeroed::<vk::StencilOp>(),
				std::mem::zeroed::<vk::StencilOp>(),
				std::mem::zeroed::<vk::StencilOp>(),
				std::mem::zeroed::<vk::CompareOp>()
			),
			Err(CallError::MissingCommand("vkCmdSetStencilOp"))
		));
		assert!(matches!(
			fixture.device.cmd_set_stencil_op(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::StencilFaceFlags>(),
				std::mem::zeroed::<vk::StencilOp>(),
				std::mem::zeroed::<vk::StencilOp>(),
				std::mem::zeroed::<vk::StencilOp>(),
				std::mem::zeroed::<vk::CompareOp>()
			),
			Err(CallError::MissingCommand("vkCmdSetStencilOp"))
		));
	}
}

#[test]
fn cmd_set_stencil_op_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: vk::StencilFaceFlags,
		arg_2: vk::StencilOp,
		arg_3: vk::StencilOp,
		arg_4: vk::StencilOp,
		arg_5: vk::CompareOp,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == vk::StencilFaceFlags::from_raw(305398016_u64 as _)
					&& arg_2 == vk::StencilOp::from_raw(305398272_u64 as _)
					&& arg_3 == vk::StencilOp::from_raw(305398528_u64 as _)
					&& arg_4 == vk::StencilOp::from_raw(305398784_u64 as _)
					&& arg_5 == vk::CompareOp::from_raw(305399040_u64 as _)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdSetStencilOp = Some(mock);
		let erased = std::mem::transmute::<vk::PFN_vkCmdSetStencilOp, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdSetStencilOp", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_set_stencil_op(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::StencilFaceFlags::from_raw(305398016_u64 as _),
			vk::StencilOp::from_raw(305398272_u64 as _),
			vk::StencilOp::from_raw(305398528_u64 as _),
			vk::StencilOp::from_raw(305398784_u64 as _),
			vk::CompareOp::from_raw(305399040_u64 as _),
		)
		.unwrap();
		vk::Device::cmd_set_stencil_op(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::StencilFaceFlags::from_raw(305398016_u64 as _),
			vk::StencilOp::from_raw(305398272_u64 as _),
			vk::StencilOp::from_raw(305398528_u64 as _),
			vk::StencilOp::from_raw(305398784_u64 as _),
			vk::CompareOp::from_raw(305399040_u64 as _),
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_set_stencil_op_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		vk::StencilFaceFlags,
		vk::StencilOp,
		vk::StencilOp,
		vk::StencilOp,
		vk::CompareOp,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_stencil_op_ext;
	let _: Signature = vk::Device::cmd_set_stencil_op_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_stencil_op_ext(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::StencilFaceFlags>(),
				std::mem::zeroed::<vk::StencilOp>(),
				std::mem::zeroed::<vk::StencilOp>(),
				std::mem::zeroed::<vk::StencilOp>(),
				std::mem::zeroed::<vk::CompareOp>()
			),
			Err(CallError::MissingCommand("vkCmdSetStencilOpEXT"))
		));
		assert!(matches!(
			fixture.device.cmd_set_stencil_op_ext(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::StencilFaceFlags>(),
				std::mem::zeroed::<vk::StencilOp>(),
				std::mem::zeroed::<vk::StencilOp>(),
				std::mem::zeroed::<vk::StencilOp>(),
				std::mem::zeroed::<vk::CompareOp>()
			),
			Err(CallError::MissingCommand("vkCmdSetStencilOpEXT"))
		));
	}
}

#[test]
fn cmd_set_stencil_op_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: vk::StencilFaceFlags,
		arg_2: vk::StencilOp,
		arg_3: vk::StencilOp,
		arg_4: vk::StencilOp,
		arg_5: vk::CompareOp,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == vk::StencilFaceFlags::from_raw(305398016_u64 as _)
					&& arg_2 == vk::StencilOp::from_raw(305398272_u64 as _)
					&& arg_3 == vk::StencilOp::from_raw(305398528_u64 as _)
					&& arg_4 == vk::StencilOp::from_raw(305398784_u64 as _)
					&& arg_5 == vk::CompareOp::from_raw(305399040_u64 as _)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdSetStencilOpEXT = Some(mock);
		let erased = std::mem::transmute::<vk::PFN_vkCmdSetStencilOpEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdSetStencilOpEXT", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_set_stencil_op_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::StencilFaceFlags::from_raw(305398016_u64 as _),
			vk::StencilOp::from_raw(305398272_u64 as _),
			vk::StencilOp::from_raw(305398528_u64 as _),
			vk::StencilOp::from_raw(305398784_u64 as _),
			vk::CompareOp::from_raw(305399040_u64 as _),
		)
		.unwrap();
		vk::Device::cmd_set_stencil_op_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::StencilFaceFlags::from_raw(305398016_u64 as _),
			vk::StencilOp::from_raw(305398272_u64 as _),
			vk::StencilOp::from_raw(305398528_u64 as _),
			vk::StencilOp::from_raw(305398784_u64 as _),
			vk::CompareOp::from_raw(305399040_u64 as _),
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_set_patch_control_points_ext_signature_and_missing_command() {
	type Signature = unsafe fn(&vk::Device, vk::CommandBuffer, u32) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_patch_control_points_ext;
	let _: Signature = vk::Device::cmd_set_patch_control_points_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_patch_control_points_ext(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>()
			),
			Err(CallError::MissingCommand("vkCmdSetPatchControlPointsEXT"))
		));
		assert!(matches!(
			fixture.device.cmd_set_patch_control_points_ext(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>()
			),
			Err(CallError::MissingCommand("vkCmdSetPatchControlPointsEXT"))
		));
	}
}

#[test]
fn cmd_set_patch_control_points_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::CommandBuffer, arg_1: u32) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == Default::default()),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdSetPatchControlPointsEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdSetPatchControlPointsEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdSetPatchControlPointsEXT", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_set_patch_control_points_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
		)
		.unwrap();
		vk::Device::cmd_set_patch_control_points_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_set_rasterizer_discard_enable_signature_and_missing_command() {
	type Signature = unsafe fn(&vk::Device, vk::CommandBuffer, vk::Bool32) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_rasterizer_discard_enable;
	let _: Signature = vk::Device::cmd_set_rasterizer_discard_enable;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_rasterizer_discard_enable(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::Bool32>()
			),
			Err(CallError::MissingCommand("vkCmdSetRasterizerDiscardEnable"))
		));
		assert!(matches!(
			fixture.device.cmd_set_rasterizer_discard_enable(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::Bool32>()
			),
			Err(CallError::MissingCommand("vkCmdSetRasterizerDiscardEnable"))
		));
	}
}

#[test]
fn cmd_set_rasterizer_discard_enable_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::CommandBuffer, arg_1: vk::Bool32) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == 305398016_u64 as vk::Bool32),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdSetRasterizerDiscardEnable = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdSetRasterizerDiscardEnable, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdSetRasterizerDiscardEnable", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_set_rasterizer_discard_enable(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			305398016_u64 as vk::Bool32,
		)
		.unwrap();
		vk::Device::cmd_set_rasterizer_discard_enable(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			305398016_u64 as vk::Bool32,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_set_rasterizer_discard_enable_ext_signature_and_missing_command() {
	type Signature = unsafe fn(&vk::Device, vk::CommandBuffer, vk::Bool32) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_rasterizer_discard_enable_ext;
	let _: Signature = vk::Device::cmd_set_rasterizer_discard_enable_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_rasterizer_discard_enable_ext(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::Bool32>()
			),
			Err(CallError::MissingCommand(
				"vkCmdSetRasterizerDiscardEnableEXT"
			))
		));
		assert!(matches!(
			fixture.device.cmd_set_rasterizer_discard_enable_ext(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::Bool32>()
			),
			Err(CallError::MissingCommand(
				"vkCmdSetRasterizerDiscardEnableEXT"
			))
		));
	}
}

#[test]
fn cmd_set_rasterizer_discard_enable_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::CommandBuffer, arg_1: vk::Bool32) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == 305398016_u64 as vk::Bool32),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdSetRasterizerDiscardEnableEXT = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkCmdSetRasterizerDiscardEnableEXT,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdSetRasterizerDiscardEnableEXT", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_set_rasterizer_discard_enable_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			305398016_u64 as vk::Bool32,
		)
		.unwrap();
		vk::Device::cmd_set_rasterizer_discard_enable_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			305398016_u64 as vk::Bool32,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_set_depth_bias_enable_signature_and_missing_command() {
	type Signature = unsafe fn(&vk::Device, vk::CommandBuffer, vk::Bool32) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_depth_bias_enable;
	let _: Signature = vk::Device::cmd_set_depth_bias_enable;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_depth_bias_enable(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::Bool32>()
			),
			Err(CallError::MissingCommand("vkCmdSetDepthBiasEnable"))
		));
		assert!(matches!(
			fixture.device.cmd_set_depth_bias_enable(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::Bool32>()
			),
			Err(CallError::MissingCommand("vkCmdSetDepthBiasEnable"))
		));
	}
}

#[test]
fn cmd_set_depth_bias_enable_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::CommandBuffer, arg_1: vk::Bool32) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == 305398016_u64 as vk::Bool32),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdSetDepthBiasEnable = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdSetDepthBiasEnable, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdSetDepthBiasEnable", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_set_depth_bias_enable(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			305398016_u64 as vk::Bool32,
		)
		.unwrap();
		vk::Device::cmd_set_depth_bias_enable(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			305398016_u64 as vk::Bool32,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_set_depth_bias_enable_ext_signature_and_missing_command() {
	type Signature = unsafe fn(&vk::Device, vk::CommandBuffer, vk::Bool32) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_depth_bias_enable_ext;
	let _: Signature = vk::Device::cmd_set_depth_bias_enable_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_depth_bias_enable_ext(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::Bool32>()
			),
			Err(CallError::MissingCommand("vkCmdSetDepthBiasEnableEXT"))
		));
		assert!(matches!(
			fixture.device.cmd_set_depth_bias_enable_ext(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::Bool32>()
			),
			Err(CallError::MissingCommand("vkCmdSetDepthBiasEnableEXT"))
		));
	}
}

#[test]
fn cmd_set_depth_bias_enable_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::CommandBuffer, arg_1: vk::Bool32) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == 305398016_u64 as vk::Bool32),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdSetDepthBiasEnableEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdSetDepthBiasEnableEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdSetDepthBiasEnableEXT", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_set_depth_bias_enable_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			305398016_u64 as vk::Bool32,
		)
		.unwrap();
		vk::Device::cmd_set_depth_bias_enable_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			305398016_u64 as vk::Bool32,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_set_logic_op_ext_signature_and_missing_command() {
	type Signature = unsafe fn(&vk::Device, vk::CommandBuffer, vk::LogicOp) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_logic_op_ext;
	let _: Signature = vk::Device::cmd_set_logic_op_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_logic_op_ext(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::LogicOp>()
			),
			Err(CallError::MissingCommand("vkCmdSetLogicOpEXT"))
		));
		assert!(matches!(
			fixture.device.cmd_set_logic_op_ext(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::LogicOp>()
			),
			Err(CallError::MissingCommand("vkCmdSetLogicOpEXT"))
		));
	}
}

#[test]
fn cmd_set_logic_op_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::CommandBuffer, arg_1: vk::LogicOp) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == vk::LogicOp::from_raw(305398016_u64 as _)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdSetLogicOpEXT = Some(mock);
		let erased = std::mem::transmute::<vk::PFN_vkCmdSetLogicOpEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdSetLogicOpEXT", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_set_logic_op_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::LogicOp::from_raw(305398016_u64 as _),
		)
		.unwrap();
		vk::Device::cmd_set_logic_op_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::LogicOp::from_raw(305398016_u64 as _),
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_set_primitive_restart_enable_signature_and_missing_command() {
	type Signature = unsafe fn(&vk::Device, vk::CommandBuffer, vk::Bool32) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_primitive_restart_enable;
	let _: Signature = vk::Device::cmd_set_primitive_restart_enable;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_primitive_restart_enable(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::Bool32>()
			),
			Err(CallError::MissingCommand("vkCmdSetPrimitiveRestartEnable"))
		));
		assert!(matches!(
			fixture.device.cmd_set_primitive_restart_enable(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::Bool32>()
			),
			Err(CallError::MissingCommand("vkCmdSetPrimitiveRestartEnable"))
		));
	}
}

#[test]
fn cmd_set_primitive_restart_enable_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::CommandBuffer, arg_1: vk::Bool32) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == 305398016_u64 as vk::Bool32),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdSetPrimitiveRestartEnable = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdSetPrimitiveRestartEnable, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdSetPrimitiveRestartEnable", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_set_primitive_restart_enable(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			305398016_u64 as vk::Bool32,
		)
		.unwrap();
		vk::Device::cmd_set_primitive_restart_enable(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			305398016_u64 as vk::Bool32,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_set_primitive_restart_enable_ext_signature_and_missing_command() {
	type Signature = unsafe fn(&vk::Device, vk::CommandBuffer, vk::Bool32) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_primitive_restart_enable_ext;
	let _: Signature = vk::Device::cmd_set_primitive_restart_enable_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_primitive_restart_enable_ext(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::Bool32>()
			),
			Err(CallError::MissingCommand(
				"vkCmdSetPrimitiveRestartEnableEXT"
			))
		));
		assert!(matches!(
			fixture.device.cmd_set_primitive_restart_enable_ext(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::Bool32>()
			),
			Err(CallError::MissingCommand(
				"vkCmdSetPrimitiveRestartEnableEXT"
			))
		));
	}
}

#[test]
fn cmd_set_primitive_restart_enable_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::CommandBuffer, arg_1: vk::Bool32) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == 305398016_u64 as vk::Bool32),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdSetPrimitiveRestartEnableEXT = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkCmdSetPrimitiveRestartEnableEXT,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdSetPrimitiveRestartEnableEXT", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_set_primitive_restart_enable_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			305398016_u64 as vk::Bool32,
		)
		.unwrap();
		vk::Device::cmd_set_primitive_restart_enable_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			305398016_u64 as vk::Bool32,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_set_tessellation_domain_origin_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		vk::TessellationDomainOrigin,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_tessellation_domain_origin_ext;
	let _: Signature = vk::Device::cmd_set_tessellation_domain_origin_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_tessellation_domain_origin_ext(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::TessellationDomainOrigin>()
			),
			Err(CallError::MissingCommand(
				"vkCmdSetTessellationDomainOriginEXT"
			))
		));
		assert!(matches!(
			fixture.device.cmd_set_tessellation_domain_origin_ext(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::TessellationDomainOrigin>()
			),
			Err(CallError::MissingCommand(
				"vkCmdSetTessellationDomainOriginEXT"
			))
		));
	}
}

#[test]
fn cmd_set_tessellation_domain_origin_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::CommandBuffer, arg_1: vk::TessellationDomainOrigin) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == vk::TessellationDomainOrigin::from_raw(305398016_u64 as _)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdSetTessellationDomainOriginEXT = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkCmdSetTessellationDomainOriginEXT,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdSetTessellationDomainOriginEXT", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_set_tessellation_domain_origin_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::TessellationDomainOrigin::from_raw(305398016_u64 as _),
		)
		.unwrap();
		vk::Device::cmd_set_tessellation_domain_origin_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::TessellationDomainOrigin::from_raw(305398016_u64 as _),
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_set_depth_clamp_enable_ext_signature_and_missing_command() {
	type Signature = unsafe fn(&vk::Device, vk::CommandBuffer, vk::Bool32) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_depth_clamp_enable_ext;
	let _: Signature = vk::Device::cmd_set_depth_clamp_enable_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_depth_clamp_enable_ext(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::Bool32>()
			),
			Err(CallError::MissingCommand("vkCmdSetDepthClampEnableEXT"))
		));
		assert!(matches!(
			fixture.device.cmd_set_depth_clamp_enable_ext(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::Bool32>()
			),
			Err(CallError::MissingCommand("vkCmdSetDepthClampEnableEXT"))
		));
	}
}

#[test]
fn cmd_set_depth_clamp_enable_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::CommandBuffer, arg_1: vk::Bool32) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == 305398016_u64 as vk::Bool32),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdSetDepthClampEnableEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdSetDepthClampEnableEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdSetDepthClampEnableEXT", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_set_depth_clamp_enable_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			305398016_u64 as vk::Bool32,
		)
		.unwrap();
		vk::Device::cmd_set_depth_clamp_enable_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			305398016_u64 as vk::Bool32,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_set_polygon_mode_ext_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, vk::CommandBuffer, vk::PolygonMode) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_polygon_mode_ext;
	let _: Signature = vk::Device::cmd_set_polygon_mode_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_polygon_mode_ext(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::PolygonMode>()
			),
			Err(CallError::MissingCommand("vkCmdSetPolygonModeEXT"))
		));
		assert!(matches!(
			fixture.device.cmd_set_polygon_mode_ext(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::PolygonMode>()
			),
			Err(CallError::MissingCommand("vkCmdSetPolygonModeEXT"))
		));
	}
}

#[test]
fn cmd_set_polygon_mode_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::CommandBuffer, arg_1: vk::PolygonMode) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == vk::PolygonMode::from_raw(305398016_u64 as _)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdSetPolygonModeEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdSetPolygonModeEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdSetPolygonModeEXT", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_set_polygon_mode_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::PolygonMode::from_raw(305398016_u64 as _),
		)
		.unwrap();
		vk::Device::cmd_set_polygon_mode_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::PolygonMode::from_raw(305398016_u64 as _),
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_set_rasterization_samples_ext_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, vk::CommandBuffer, vk::SampleCountFlagBits) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_rasterization_samples_ext;
	let _: Signature = vk::Device::cmd_set_rasterization_samples_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_rasterization_samples_ext(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::SampleCountFlagBits>()
			),
			Err(CallError::MissingCommand("vkCmdSetRasterizationSamplesEXT"))
		));
		assert!(matches!(
			fixture.device.cmd_set_rasterization_samples_ext(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::SampleCountFlagBits>()
			),
			Err(CallError::MissingCommand("vkCmdSetRasterizationSamplesEXT"))
		));
	}
}

#[test]
fn cmd_set_rasterization_samples_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::CommandBuffer, arg_1: vk::SampleCountFlagBits) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == vk::SampleCountFlagBits::from_raw(305398016_u64 as _)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdSetRasterizationSamplesEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdSetRasterizationSamplesEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdSetRasterizationSamplesEXT", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_set_rasterization_samples_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::SampleCountFlagBits::from_raw(305398016_u64 as _),
		)
		.unwrap();
		vk::Device::cmd_set_rasterization_samples_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::SampleCountFlagBits::from_raw(305398016_u64 as _),
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_set_sample_mask_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		vk::SampleCountFlagBits,
		*const vk::SampleMask,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_sample_mask_ext;
	let _: Signature = vk::Device::cmd_set_sample_mask_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_sample_mask_ext(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::SampleCountFlagBits>(),
				std::mem::zeroed::<*const vk::SampleMask>()
			),
			Err(CallError::MissingCommand("vkCmdSetSampleMaskEXT"))
		));
		assert!(matches!(
			fixture.device.cmd_set_sample_mask_ext(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::SampleCountFlagBits>(),
				std::mem::zeroed::<*const vk::SampleMask>()
			),
			Err(CallError::MissingCommand("vkCmdSetSampleMaskEXT"))
		));
	}
}

#[test]
fn cmd_set_sample_mask_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: vk::SampleCountFlagBits,
		arg_2: *const vk::SampleMask,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == vk::SampleCountFlagBits::from_raw(305398016_u64 as _)
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *const vk::SampleMask,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdSetSampleMaskEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdSetSampleMaskEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdSetSampleMaskEXT", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_set_sample_mask_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::SampleCountFlagBits::from_raw(305398016_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *const vk::SampleMask,
		)
		.unwrap();
		vk::Device::cmd_set_sample_mask_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::SampleCountFlagBits::from_raw(305398016_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *const vk::SampleMask,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_set_alpha_to_coverage_enable_ext_signature_and_missing_command() {
	type Signature = unsafe fn(&vk::Device, vk::CommandBuffer, vk::Bool32) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_alpha_to_coverage_enable_ext;
	let _: Signature = vk::Device::cmd_set_alpha_to_coverage_enable_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_alpha_to_coverage_enable_ext(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::Bool32>()
			),
			Err(CallError::MissingCommand(
				"vkCmdSetAlphaToCoverageEnableEXT"
			))
		));
		assert!(matches!(
			fixture.device.cmd_set_alpha_to_coverage_enable_ext(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::Bool32>()
			),
			Err(CallError::MissingCommand(
				"vkCmdSetAlphaToCoverageEnableEXT"
			))
		));
	}
}

#[test]
fn cmd_set_alpha_to_coverage_enable_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::CommandBuffer, arg_1: vk::Bool32) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == 305398016_u64 as vk::Bool32),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdSetAlphaToCoverageEnableEXT = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkCmdSetAlphaToCoverageEnableEXT,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdSetAlphaToCoverageEnableEXT", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_set_alpha_to_coverage_enable_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			305398016_u64 as vk::Bool32,
		)
		.unwrap();
		vk::Device::cmd_set_alpha_to_coverage_enable_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			305398016_u64 as vk::Bool32,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_set_alpha_to_one_enable_ext_signature_and_missing_command() {
	type Signature = unsafe fn(&vk::Device, vk::CommandBuffer, vk::Bool32) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_alpha_to_one_enable_ext;
	let _: Signature = vk::Device::cmd_set_alpha_to_one_enable_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_alpha_to_one_enable_ext(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::Bool32>()
			),
			Err(CallError::MissingCommand("vkCmdSetAlphaToOneEnableEXT"))
		));
		assert!(matches!(
			fixture.device.cmd_set_alpha_to_one_enable_ext(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::Bool32>()
			),
			Err(CallError::MissingCommand("vkCmdSetAlphaToOneEnableEXT"))
		));
	}
}

#[test]
fn cmd_set_alpha_to_one_enable_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::CommandBuffer, arg_1: vk::Bool32) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == 305398016_u64 as vk::Bool32),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdSetAlphaToOneEnableEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdSetAlphaToOneEnableEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdSetAlphaToOneEnableEXT", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_set_alpha_to_one_enable_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			305398016_u64 as vk::Bool32,
		)
		.unwrap();
		vk::Device::cmd_set_alpha_to_one_enable_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			305398016_u64 as vk::Bool32,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_set_logic_op_enable_ext_signature_and_missing_command() {
	type Signature = unsafe fn(&vk::Device, vk::CommandBuffer, vk::Bool32) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_logic_op_enable_ext;
	let _: Signature = vk::Device::cmd_set_logic_op_enable_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_logic_op_enable_ext(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::Bool32>()
			),
			Err(CallError::MissingCommand("vkCmdSetLogicOpEnableEXT"))
		));
		assert!(matches!(
			fixture.device.cmd_set_logic_op_enable_ext(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::Bool32>()
			),
			Err(CallError::MissingCommand("vkCmdSetLogicOpEnableEXT"))
		));
	}
}

#[test]
fn cmd_set_logic_op_enable_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::CommandBuffer, arg_1: vk::Bool32) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == 305398016_u64 as vk::Bool32),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdSetLogicOpEnableEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdSetLogicOpEnableEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdSetLogicOpEnableEXT", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_set_logic_op_enable_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			305398016_u64 as vk::Bool32,
		)
		.unwrap();
		vk::Device::cmd_set_logic_op_enable_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			305398016_u64 as vk::Bool32,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_set_color_blend_enable_ext_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, vk::CommandBuffer, u32, u32, *const vk::Bool32) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_color_blend_enable_ext;
	let _: Signature = vk::Device::cmd_set_color_blend_enable_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_color_blend_enable_ext(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::Bool32>()
			),
			Err(CallError::MissingCommand("vkCmdSetColorBlendEnableEXT"))
		));
		assert!(matches!(
			fixture.device.cmd_set_color_blend_enable_ext(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::Bool32>()
			),
			Err(CallError::MissingCommand("vkCmdSetColorBlendEnableEXT"))
		));
	}
}

#[test]
fn cmd_set_color_blend_enable_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: u32,
		arg_2: u32,
		arg_3: *const vk::Bool32,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == Default::default()
					&& arg_2 == Default::default()
					&& std::ptr::eq(
						arg_3,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *const vk::Bool32,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdSetColorBlendEnableEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdSetColorBlendEnableEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdSetColorBlendEnableEXT", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_set_color_blend_enable_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *const vk::Bool32,
		)
		.unwrap();
		vk::Device::cmd_set_color_blend_enable_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *const vk::Bool32,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_set_color_blend_equation_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		u32,
		u32,
		*const vk::ColorBlendEquationEXT,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_color_blend_equation_ext;
	let _: Signature = vk::Device::cmd_set_color_blend_equation_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_color_blend_equation_ext(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::ColorBlendEquationEXT>()
			),
			Err(CallError::MissingCommand("vkCmdSetColorBlendEquationEXT"))
		));
		assert!(matches!(
			fixture.device.cmd_set_color_blend_equation_ext(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::ColorBlendEquationEXT>()
			),
			Err(CallError::MissingCommand("vkCmdSetColorBlendEquationEXT"))
		));
	}
}

#[test]
fn cmd_set_color_blend_equation_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: u32,
		arg_2: u32,
		arg_3: *const vk::ColorBlendEquationEXT,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == Default::default()
					&& arg_2 == Default::default()
					&& std::ptr::eq(
						arg_3,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
							as *const vk::ColorBlendEquationEXT,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdSetColorBlendEquationEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdSetColorBlendEquationEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdSetColorBlendEquationEXT", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_set_color_blend_equation_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
				as *const vk::ColorBlendEquationEXT,
		)
		.unwrap();
		vk::Device::cmd_set_color_blend_equation_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
				as *const vk::ColorBlendEquationEXT,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_set_color_write_mask_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		u32,
		u32,
		*const vk::ColorComponentFlags,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_color_write_mask_ext;
	let _: Signature = vk::Device::cmd_set_color_write_mask_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_color_write_mask_ext(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::ColorComponentFlags>()
			),
			Err(CallError::MissingCommand("vkCmdSetColorWriteMaskEXT"))
		));
		assert!(matches!(
			fixture.device.cmd_set_color_write_mask_ext(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::ColorComponentFlags>()
			),
			Err(CallError::MissingCommand("vkCmdSetColorWriteMaskEXT"))
		));
	}
}

#[test]
fn cmd_set_color_write_mask_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: u32,
		arg_2: u32,
		arg_3: *const vk::ColorComponentFlags,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == Default::default()
					&& arg_2 == Default::default()
					&& std::ptr::eq(
						arg_3,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
							as *const vk::ColorComponentFlags,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdSetColorWriteMaskEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdSetColorWriteMaskEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdSetColorWriteMaskEXT", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_set_color_write_mask_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
				as *const vk::ColorComponentFlags,
		)
		.unwrap();
		vk::Device::cmd_set_color_write_mask_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
				as *const vk::ColorComponentFlags,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_set_rasterization_stream_ext_signature_and_missing_command() {
	type Signature = unsafe fn(&vk::Device, vk::CommandBuffer, u32) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_rasterization_stream_ext;
	let _: Signature = vk::Device::cmd_set_rasterization_stream_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_rasterization_stream_ext(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>()
			),
			Err(CallError::MissingCommand("vkCmdSetRasterizationStreamEXT"))
		));
		assert!(matches!(
			fixture.device.cmd_set_rasterization_stream_ext(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>()
			),
			Err(CallError::MissingCommand("vkCmdSetRasterizationStreamEXT"))
		));
	}
}

#[test]
fn cmd_set_rasterization_stream_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::CommandBuffer, arg_1: u32) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == Default::default()),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdSetRasterizationStreamEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdSetRasterizationStreamEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdSetRasterizationStreamEXT", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_set_rasterization_stream_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
		)
		.unwrap();
		vk::Device::cmd_set_rasterization_stream_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_set_conservative_rasterization_mode_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		vk::ConservativeRasterizationModeEXT,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_conservative_rasterization_mode_ext;
	let _: Signature = vk::Device::cmd_set_conservative_rasterization_mode_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_conservative_rasterization_mode_ext(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::ConservativeRasterizationModeEXT>()
			),
			Err(CallError::MissingCommand(
				"vkCmdSetConservativeRasterizationModeEXT"
			))
		));
		assert!(matches!(
			fixture.device.cmd_set_conservative_rasterization_mode_ext(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::ConservativeRasterizationModeEXT>()
			),
			Err(CallError::MissingCommand(
				"vkCmdSetConservativeRasterizationModeEXT"
			))
		));
	}
}

#[test]
fn cmd_set_conservative_rasterization_mode_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: vk::ConservativeRasterizationModeEXT,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == vk::ConservativeRasterizationModeEXT::from_raw(305398016_u64 as _)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdSetConservativeRasterizationModeEXT = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkCmdSetConservativeRasterizationModeEXT,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdSetConservativeRasterizationModeEXT", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_set_conservative_rasterization_mode_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::ConservativeRasterizationModeEXT::from_raw(305398016_u64 as _),
		)
		.unwrap();
		vk::Device::cmd_set_conservative_rasterization_mode_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::ConservativeRasterizationModeEXT::from_raw(305398016_u64 as _),
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_set_extra_primitive_overestimation_size_ext_signature_and_missing_command() {
	type Signature = unsafe fn(&vk::Device, vk::CommandBuffer, f32) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_extra_primitive_overestimation_size_ext;
	let _: Signature = vk::Device::cmd_set_extra_primitive_overestimation_size_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_extra_primitive_overestimation_size_ext(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<f32>()
			),
			Err(CallError::MissingCommand(
				"vkCmdSetExtraPrimitiveOverestimationSizeEXT"
			))
		));
		assert!(matches!(
			fixture
				.device
				.cmd_set_extra_primitive_overestimation_size_ext(
					std::mem::zeroed::<vk::CommandBuffer>(),
					std::mem::zeroed::<f32>()
				),
			Err(CallError::MissingCommand(
				"vkCmdSetExtraPrimitiveOverestimationSizeEXT"
			))
		));
	}
}

#[test]
fn cmd_set_extra_primitive_overestimation_size_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::CommandBuffer, arg_1: f32) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == Default::default()),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdSetExtraPrimitiveOverestimationSizeEXT", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_set_extra_primitive_overestimation_size_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
		)
		.unwrap();
		vk::Device::cmd_set_extra_primitive_overestimation_size_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_set_depth_clip_enable_ext_signature_and_missing_command() {
	type Signature = unsafe fn(&vk::Device, vk::CommandBuffer, vk::Bool32) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_depth_clip_enable_ext;
	let _: Signature = vk::Device::cmd_set_depth_clip_enable_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_depth_clip_enable_ext(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::Bool32>()
			),
			Err(CallError::MissingCommand("vkCmdSetDepthClipEnableEXT"))
		));
		assert!(matches!(
			fixture.device.cmd_set_depth_clip_enable_ext(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::Bool32>()
			),
			Err(CallError::MissingCommand("vkCmdSetDepthClipEnableEXT"))
		));
	}
}

#[test]
fn cmd_set_depth_clip_enable_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::CommandBuffer, arg_1: vk::Bool32) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == 305398016_u64 as vk::Bool32),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdSetDepthClipEnableEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdSetDepthClipEnableEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdSetDepthClipEnableEXT", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_set_depth_clip_enable_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			305398016_u64 as vk::Bool32,
		)
		.unwrap();
		vk::Device::cmd_set_depth_clip_enable_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			305398016_u64 as vk::Bool32,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_set_sample_locations_enable_ext_signature_and_missing_command() {
	type Signature = unsafe fn(&vk::Device, vk::CommandBuffer, vk::Bool32) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_sample_locations_enable_ext;
	let _: Signature = vk::Device::cmd_set_sample_locations_enable_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_sample_locations_enable_ext(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::Bool32>()
			),
			Err(CallError::MissingCommand(
				"vkCmdSetSampleLocationsEnableEXT"
			))
		));
		assert!(matches!(
			fixture.device.cmd_set_sample_locations_enable_ext(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::Bool32>()
			),
			Err(CallError::MissingCommand(
				"vkCmdSetSampleLocationsEnableEXT"
			))
		));
	}
}

#[test]
fn cmd_set_sample_locations_enable_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::CommandBuffer, arg_1: vk::Bool32) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == 305398016_u64 as vk::Bool32),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdSetSampleLocationsEnableEXT = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkCmdSetSampleLocationsEnableEXT,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdSetSampleLocationsEnableEXT", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_set_sample_locations_enable_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			305398016_u64 as vk::Bool32,
		)
		.unwrap();
		vk::Device::cmd_set_sample_locations_enable_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			305398016_u64 as vk::Bool32,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_set_color_blend_advanced_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		u32,
		u32,
		*const vk::ColorBlendAdvancedEXT,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_color_blend_advanced_ext;
	let _: Signature = vk::Device::cmd_set_color_blend_advanced_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_color_blend_advanced_ext(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::ColorBlendAdvancedEXT>()
			),
			Err(CallError::MissingCommand("vkCmdSetColorBlendAdvancedEXT"))
		));
		assert!(matches!(
			fixture.device.cmd_set_color_blend_advanced_ext(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::ColorBlendAdvancedEXT>()
			),
			Err(CallError::MissingCommand("vkCmdSetColorBlendAdvancedEXT"))
		));
	}
}

#[test]
fn cmd_set_color_blend_advanced_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: u32,
		arg_2: u32,
		arg_3: *const vk::ColorBlendAdvancedEXT,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == Default::default()
					&& arg_2 == Default::default()
					&& std::ptr::eq(
						arg_3,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
							as *const vk::ColorBlendAdvancedEXT,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdSetColorBlendAdvancedEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdSetColorBlendAdvancedEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdSetColorBlendAdvancedEXT", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_set_color_blend_advanced_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
				as *const vk::ColorBlendAdvancedEXT,
		)
		.unwrap();
		vk::Device::cmd_set_color_blend_advanced_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
				as *const vk::ColorBlendAdvancedEXT,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_set_provoking_vertex_mode_ext_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, vk::CommandBuffer, vk::ProvokingVertexModeEXT) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_provoking_vertex_mode_ext;
	let _: Signature = vk::Device::cmd_set_provoking_vertex_mode_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_provoking_vertex_mode_ext(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::ProvokingVertexModeEXT>()
			),
			Err(CallError::MissingCommand("vkCmdSetProvokingVertexModeEXT"))
		));
		assert!(matches!(
			fixture.device.cmd_set_provoking_vertex_mode_ext(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::ProvokingVertexModeEXT>()
			),
			Err(CallError::MissingCommand("vkCmdSetProvokingVertexModeEXT"))
		));
	}
}

#[test]
fn cmd_set_provoking_vertex_mode_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::CommandBuffer, arg_1: vk::ProvokingVertexModeEXT) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == vk::ProvokingVertexModeEXT::from_raw(305398016_u64 as _)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdSetProvokingVertexModeEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdSetProvokingVertexModeEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdSetProvokingVertexModeEXT", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_set_provoking_vertex_mode_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::ProvokingVertexModeEXT::from_raw(305398016_u64 as _),
		)
		.unwrap();
		vk::Device::cmd_set_provoking_vertex_mode_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::ProvokingVertexModeEXT::from_raw(305398016_u64 as _),
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_set_line_rasterization_mode_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		vk::LineRasterizationModeEXT,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_line_rasterization_mode_ext;
	let _: Signature = vk::Device::cmd_set_line_rasterization_mode_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_line_rasterization_mode_ext(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::LineRasterizationModeEXT>()
			),
			Err(CallError::MissingCommand(
				"vkCmdSetLineRasterizationModeEXT"
			))
		));
		assert!(matches!(
			fixture.device.cmd_set_line_rasterization_mode_ext(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::LineRasterizationModeEXT>()
			),
			Err(CallError::MissingCommand(
				"vkCmdSetLineRasterizationModeEXT"
			))
		));
	}
}

#[test]
fn cmd_set_line_rasterization_mode_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::CommandBuffer, arg_1: vk::LineRasterizationModeEXT) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == vk::LineRasterizationMode::from_raw(305398016_u64 as _)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdSetLineRasterizationModeEXT = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkCmdSetLineRasterizationModeEXT,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdSetLineRasterizationModeEXT", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_set_line_rasterization_mode_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::LineRasterizationMode::from_raw(305398016_u64 as _),
		)
		.unwrap();
		vk::Device::cmd_set_line_rasterization_mode_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::LineRasterizationMode::from_raw(305398016_u64 as _),
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_set_line_stipple_enable_ext_signature_and_missing_command() {
	type Signature = unsafe fn(&vk::Device, vk::CommandBuffer, vk::Bool32) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_line_stipple_enable_ext;
	let _: Signature = vk::Device::cmd_set_line_stipple_enable_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_line_stipple_enable_ext(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::Bool32>()
			),
			Err(CallError::MissingCommand("vkCmdSetLineStippleEnableEXT"))
		));
		assert!(matches!(
			fixture.device.cmd_set_line_stipple_enable_ext(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::Bool32>()
			),
			Err(CallError::MissingCommand("vkCmdSetLineStippleEnableEXT"))
		));
	}
}

#[test]
fn cmd_set_line_stipple_enable_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::CommandBuffer, arg_1: vk::Bool32) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == 305398016_u64 as vk::Bool32),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdSetLineStippleEnableEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdSetLineStippleEnableEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdSetLineStippleEnableEXT", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_set_line_stipple_enable_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			305398016_u64 as vk::Bool32,
		)
		.unwrap();
		vk::Device::cmd_set_line_stipple_enable_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			305398016_u64 as vk::Bool32,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_set_depth_clip_negative_one_to_one_ext_signature_and_missing_command() {
	type Signature = unsafe fn(&vk::Device, vk::CommandBuffer, vk::Bool32) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_depth_clip_negative_one_to_one_ext;
	let _: Signature = vk::Device::cmd_set_depth_clip_negative_one_to_one_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_depth_clip_negative_one_to_one_ext(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::Bool32>()
			),
			Err(CallError::MissingCommand(
				"vkCmdSetDepthClipNegativeOneToOneEXT"
			))
		));
		assert!(matches!(
			fixture.device.cmd_set_depth_clip_negative_one_to_one_ext(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::Bool32>()
			),
			Err(CallError::MissingCommand(
				"vkCmdSetDepthClipNegativeOneToOneEXT"
			))
		));
	}
}

#[test]
fn cmd_set_depth_clip_negative_one_to_one_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::CommandBuffer, arg_1: vk::Bool32) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == 305398016_u64 as vk::Bool32),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdSetDepthClipNegativeOneToOneEXT = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkCmdSetDepthClipNegativeOneToOneEXT,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdSetDepthClipNegativeOneToOneEXT", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_set_depth_clip_negative_one_to_one_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			305398016_u64 as vk::Bool32,
		)
		.unwrap();
		vk::Device::cmd_set_depth_clip_negative_one_to_one_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			305398016_u64 as vk::Bool32,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_set_viewport_w_scaling_enable_nv_signature_and_missing_command() {
	type Signature = unsafe fn(&vk::Device, vk::CommandBuffer, vk::Bool32) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_viewport_w_scaling_enable_nv;
	let _: Signature = vk::Device::cmd_set_viewport_w_scaling_enable_nv;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_viewport_w_scaling_enable_nv(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::Bool32>()
			),
			Err(CallError::MissingCommand(
				"vkCmdSetViewportWScalingEnableNV"
			))
		));
		assert!(matches!(
			fixture.device.cmd_set_viewport_w_scaling_enable_nv(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::Bool32>()
			),
			Err(CallError::MissingCommand(
				"vkCmdSetViewportWScalingEnableNV"
			))
		));
	}
}

#[test]
fn cmd_set_viewport_w_scaling_enable_nv_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::CommandBuffer, arg_1: vk::Bool32) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == 305398016_u64 as vk::Bool32),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdSetViewportWScalingEnableNV = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkCmdSetViewportWScalingEnableNV,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdSetViewportWScalingEnableNV", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_set_viewport_w_scaling_enable_nv(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			305398016_u64 as vk::Bool32,
		)
		.unwrap();
		vk::Device::cmd_set_viewport_w_scaling_enable_nv(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			305398016_u64 as vk::Bool32,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_set_viewport_swizzle_nv_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		u32,
		u32,
		*const vk::ViewportSwizzleNV,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_viewport_swizzle_nv;
	let _: Signature = vk::Device::cmd_set_viewport_swizzle_nv;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_viewport_swizzle_nv(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::ViewportSwizzleNV>()
			),
			Err(CallError::MissingCommand("vkCmdSetViewportSwizzleNV"))
		));
		assert!(matches!(
			fixture.device.cmd_set_viewport_swizzle_nv(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::ViewportSwizzleNV>()
			),
			Err(CallError::MissingCommand("vkCmdSetViewportSwizzleNV"))
		));
	}
}

#[test]
fn cmd_set_viewport_swizzle_nv_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: u32,
		arg_2: u32,
		arg_3: *const vk::ViewportSwizzleNV,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == Default::default()
					&& arg_2 == Default::default()
					&& std::ptr::eq(
						arg_3,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
							as *const vk::ViewportSwizzleNV,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdSetViewportSwizzleNV = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdSetViewportSwizzleNV, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdSetViewportSwizzleNV", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_set_viewport_swizzle_nv(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
				as *const vk::ViewportSwizzleNV,
		)
		.unwrap();
		vk::Device::cmd_set_viewport_swizzle_nv(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
				as *const vk::ViewportSwizzleNV,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_set_coverage_to_color_enable_nv_signature_and_missing_command() {
	type Signature = unsafe fn(&vk::Device, vk::CommandBuffer, vk::Bool32) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_coverage_to_color_enable_nv;
	let _: Signature = vk::Device::cmd_set_coverage_to_color_enable_nv;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_coverage_to_color_enable_nv(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::Bool32>()
			),
			Err(CallError::MissingCommand("vkCmdSetCoverageToColorEnableNV"))
		));
		assert!(matches!(
			fixture.device.cmd_set_coverage_to_color_enable_nv(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::Bool32>()
			),
			Err(CallError::MissingCommand("vkCmdSetCoverageToColorEnableNV"))
		));
	}
}

#[test]
fn cmd_set_coverage_to_color_enable_nv_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::CommandBuffer, arg_1: vk::Bool32) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == 305398016_u64 as vk::Bool32),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdSetCoverageToColorEnableNV = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdSetCoverageToColorEnableNV, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdSetCoverageToColorEnableNV", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_set_coverage_to_color_enable_nv(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			305398016_u64 as vk::Bool32,
		)
		.unwrap();
		vk::Device::cmd_set_coverage_to_color_enable_nv(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			305398016_u64 as vk::Bool32,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_set_coverage_to_color_location_nv_signature_and_missing_command() {
	type Signature = unsafe fn(&vk::Device, vk::CommandBuffer, u32) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_coverage_to_color_location_nv;
	let _: Signature = vk::Device::cmd_set_coverage_to_color_location_nv;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_coverage_to_color_location_nv(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>()
			),
			Err(CallError::MissingCommand(
				"vkCmdSetCoverageToColorLocationNV"
			))
		));
		assert!(matches!(
			fixture.device.cmd_set_coverage_to_color_location_nv(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>()
			),
			Err(CallError::MissingCommand(
				"vkCmdSetCoverageToColorLocationNV"
			))
		));
	}
}

#[test]
fn cmd_set_coverage_to_color_location_nv_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::CommandBuffer, arg_1: u32) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == Default::default()),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdSetCoverageToColorLocationNV = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkCmdSetCoverageToColorLocationNV,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdSetCoverageToColorLocationNV", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_set_coverage_to_color_location_nv(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
		)
		.unwrap();
		vk::Device::cmd_set_coverage_to_color_location_nv(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_set_coverage_modulation_mode_nv_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		vk::CoverageModulationModeNV,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_coverage_modulation_mode_nv;
	let _: Signature = vk::Device::cmd_set_coverage_modulation_mode_nv;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_coverage_modulation_mode_nv(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::CoverageModulationModeNV>()
			),
			Err(CallError::MissingCommand(
				"vkCmdSetCoverageModulationModeNV"
			))
		));
		assert!(matches!(
			fixture.device.cmd_set_coverage_modulation_mode_nv(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::CoverageModulationModeNV>()
			),
			Err(CallError::MissingCommand(
				"vkCmdSetCoverageModulationModeNV"
			))
		));
	}
}

#[test]
fn cmd_set_coverage_modulation_mode_nv_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::CommandBuffer, arg_1: vk::CoverageModulationModeNV) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == vk::CoverageModulationModeNV::from_raw(305398016_u64 as _)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdSetCoverageModulationModeNV = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkCmdSetCoverageModulationModeNV,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdSetCoverageModulationModeNV", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_set_coverage_modulation_mode_nv(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::CoverageModulationModeNV::from_raw(305398016_u64 as _),
		)
		.unwrap();
		vk::Device::cmd_set_coverage_modulation_mode_nv(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::CoverageModulationModeNV::from_raw(305398016_u64 as _),
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_set_coverage_modulation_table_enable_nv_signature_and_missing_command() {
	type Signature = unsafe fn(&vk::Device, vk::CommandBuffer, vk::Bool32) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_coverage_modulation_table_enable_nv;
	let _: Signature = vk::Device::cmd_set_coverage_modulation_table_enable_nv;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_coverage_modulation_table_enable_nv(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::Bool32>()
			),
			Err(CallError::MissingCommand(
				"vkCmdSetCoverageModulationTableEnableNV"
			))
		));
		assert!(matches!(
			fixture.device.cmd_set_coverage_modulation_table_enable_nv(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::Bool32>()
			),
			Err(CallError::MissingCommand(
				"vkCmdSetCoverageModulationTableEnableNV"
			))
		));
	}
}

#[test]
fn cmd_set_coverage_modulation_table_enable_nv_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::CommandBuffer, arg_1: vk::Bool32) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == 305398016_u64 as vk::Bool32),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdSetCoverageModulationTableEnableNV = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkCmdSetCoverageModulationTableEnableNV,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdSetCoverageModulationTableEnableNV", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_set_coverage_modulation_table_enable_nv(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			305398016_u64 as vk::Bool32,
		)
		.unwrap();
		vk::Device::cmd_set_coverage_modulation_table_enable_nv(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			305398016_u64 as vk::Bool32,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_set_coverage_modulation_table_nv_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, vk::CommandBuffer, u32, *const f32) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_coverage_modulation_table_nv;
	let _: Signature = vk::Device::cmd_set_coverage_modulation_table_nv;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_coverage_modulation_table_nv(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const f32>()
			),
			Err(CallError::MissingCommand(
				"vkCmdSetCoverageModulationTableNV"
			))
		));
		assert!(matches!(
			fixture.device.cmd_set_coverage_modulation_table_nv(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const f32>()
			),
			Err(CallError::MissingCommand(
				"vkCmdSetCoverageModulationTableNV"
			))
		));
	}
}

#[test]
fn cmd_set_coverage_modulation_table_nv_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::CommandBuffer, arg_1: u32, arg_2: *const f32) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == Default::default()
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *const f32,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdSetCoverageModulationTableNV = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkCmdSetCoverageModulationTableNV,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdSetCoverageModulationTableNV", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_set_coverage_modulation_table_nv(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *const f32,
		)
		.unwrap();
		vk::Device::cmd_set_coverage_modulation_table_nv(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *const f32,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_set_shading_rate_image_enable_nv_signature_and_missing_command() {
	type Signature = unsafe fn(&vk::Device, vk::CommandBuffer, vk::Bool32) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_shading_rate_image_enable_nv;
	let _: Signature = vk::Device::cmd_set_shading_rate_image_enable_nv;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_shading_rate_image_enable_nv(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::Bool32>()
			),
			Err(CallError::MissingCommand(
				"vkCmdSetShadingRateImageEnableNV"
			))
		));
		assert!(matches!(
			fixture.device.cmd_set_shading_rate_image_enable_nv(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::Bool32>()
			),
			Err(CallError::MissingCommand(
				"vkCmdSetShadingRateImageEnableNV"
			))
		));
	}
}

#[test]
fn cmd_set_shading_rate_image_enable_nv_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::CommandBuffer, arg_1: vk::Bool32) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == 305398016_u64 as vk::Bool32),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdSetShadingRateImageEnableNV = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkCmdSetShadingRateImageEnableNV,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdSetShadingRateImageEnableNV", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_set_shading_rate_image_enable_nv(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			305398016_u64 as vk::Bool32,
		)
		.unwrap();
		vk::Device::cmd_set_shading_rate_image_enable_nv(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			305398016_u64 as vk::Bool32,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_set_coverage_reduction_mode_nv_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, vk::CommandBuffer, vk::CoverageReductionModeNV) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_coverage_reduction_mode_nv;
	let _: Signature = vk::Device::cmd_set_coverage_reduction_mode_nv;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_coverage_reduction_mode_nv(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::CoverageReductionModeNV>()
			),
			Err(CallError::MissingCommand("vkCmdSetCoverageReductionModeNV"))
		));
		assert!(matches!(
			fixture.device.cmd_set_coverage_reduction_mode_nv(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::CoverageReductionModeNV>()
			),
			Err(CallError::MissingCommand("vkCmdSetCoverageReductionModeNV"))
		));
	}
}

#[test]
fn cmd_set_coverage_reduction_mode_nv_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::CommandBuffer, arg_1: vk::CoverageReductionModeNV) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == vk::CoverageReductionModeNV::from_raw(305398016_u64 as _)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdSetCoverageReductionModeNV = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdSetCoverageReductionModeNV, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdSetCoverageReductionModeNV", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_set_coverage_reduction_mode_nv(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::CoverageReductionModeNV::from_raw(305398016_u64 as _),
		)
		.unwrap();
		vk::Device::cmd_set_coverage_reduction_mode_nv(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::CoverageReductionModeNV::from_raw(305398016_u64 as _),
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_set_representative_fragment_test_enable_nv_signature_and_missing_command() {
	type Signature = unsafe fn(&vk::Device, vk::CommandBuffer, vk::Bool32) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_representative_fragment_test_enable_nv;
	let _: Signature = vk::Device::cmd_set_representative_fragment_test_enable_nv;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_representative_fragment_test_enable_nv(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::Bool32>()
			),
			Err(CallError::MissingCommand(
				"vkCmdSetRepresentativeFragmentTestEnableNV"
			))
		));
		assert!(matches!(
			fixture
				.device
				.cmd_set_representative_fragment_test_enable_nv(
					std::mem::zeroed::<vk::CommandBuffer>(),
					std::mem::zeroed::<vk::Bool32>()
				),
			Err(CallError::MissingCommand(
				"vkCmdSetRepresentativeFragmentTestEnableNV"
			))
		));
	}
}

#[test]
fn cmd_set_representative_fragment_test_enable_nv_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::CommandBuffer, arg_1: vk::Bool32) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == 305398016_u64 as vk::Bool32),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdSetRepresentativeFragmentTestEnableNV = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkCmdSetRepresentativeFragmentTestEnableNV,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdSetRepresentativeFragmentTestEnableNV", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_set_representative_fragment_test_enable_nv(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			305398016_u64 as vk::Bool32,
		)
		.unwrap();
		vk::Device::cmd_set_representative_fragment_test_enable_nv(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			305398016_u64 as vk::Bool32,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn create_private_data_slot_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::PrivateDataSlotCreateInfo<'_>,
		*const vk::AllocationCallbacks,
		*mut vk::PrivateDataSlot,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::create_private_data_slot;
	let _: Signature = vk::Device::create_private_data_slot;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::create_private_data_slot(
				&fixture.device,
				std::mem::zeroed::<*const vk::PrivateDataSlotCreateInfo<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::PrivateDataSlot>()
			),
			Err(CallError::MissingCommand("vkCreatePrivateDataSlot"))
		));
		assert!(matches!(
			fixture.device.create_private_data_slot(
				std::mem::zeroed::<*const vk::PrivateDataSlotCreateInfo<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::PrivateDataSlot>()
			),
			Err(CallError::MissingCommand("vkCreatePrivateDataSlot"))
		));
	}
}

#[test]
fn create_private_data_slot_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::PrivateDataSlotCreateInfo<'_>,
		arg_2: *const vk::AllocationCallbacks,
		arg_3: *mut vk::PrivateDataSlot,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::PrivateDataSlotCreateInfo<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
				) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::PrivateDataSlot,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCreatePrivateDataSlot = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCreatePrivateDataSlot, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCreatePrivateDataSlot", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::create_private_data_slot(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::PrivateDataSlotCreateInfo<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::PrivateDataSlot
				),
				expected
			);
			assert_eq!(
				vk::Device::create_private_data_slot(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::PrivateDataSlotCreateInfo<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::PrivateDataSlot
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn create_private_data_slot_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::PrivateDataSlotCreateInfo<'_>,
		*const vk::AllocationCallbacks,
		*mut vk::PrivateDataSlot,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::create_private_data_slot_ext;
	let _: Signature = vk::Device::create_private_data_slot_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::create_private_data_slot_ext(
				&fixture.device,
				std::mem::zeroed::<*const vk::PrivateDataSlotCreateInfo<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::PrivateDataSlot>()
			),
			Err(CallError::MissingCommand("vkCreatePrivateDataSlotEXT"))
		));
		assert!(matches!(
			fixture.device.create_private_data_slot_ext(
				std::mem::zeroed::<*const vk::PrivateDataSlotCreateInfo<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::PrivateDataSlot>()
			),
			Err(CallError::MissingCommand("vkCreatePrivateDataSlotEXT"))
		));
	}
}

#[test]
fn create_private_data_slot_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::PrivateDataSlotCreateInfo<'_>,
		arg_2: *const vk::AllocationCallbacks,
		arg_3: *mut vk::PrivateDataSlot,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::PrivateDataSlotCreateInfo<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
				) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::PrivateDataSlot,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCreatePrivateDataSlotEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCreatePrivateDataSlotEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCreatePrivateDataSlotEXT", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::create_private_data_slot_ext(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::PrivateDataSlotCreateInfo<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::PrivateDataSlot
				),
				expected
			);
			assert_eq!(
				vk::Device::create_private_data_slot_ext(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::PrivateDataSlotCreateInfo<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::PrivateDataSlot
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn destroy_private_data_slot_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::PrivateDataSlot,
		*const vk::AllocationCallbacks,
	) -> Result<(), CallError>;
	let _: Signature = vk::destroy_private_data_slot;
	let _: Signature = vk::Device::destroy_private_data_slot;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::destroy_private_data_slot(
				&fixture.device,
				std::mem::zeroed::<vk::PrivateDataSlot>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>()
			),
			Err(CallError::MissingCommand("vkDestroyPrivateDataSlot"))
		));
		assert!(matches!(
			fixture.device.destroy_private_data_slot(
				std::mem::zeroed::<vk::PrivateDataSlot>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>()
			),
			Err(CallError::MissingCommand("vkDestroyPrivateDataSlot"))
		));
	}
}

#[test]
fn destroy_private_data_slot_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::PrivateDataSlot,
		arg_2: *const vk::AllocationCallbacks,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::PrivateDataSlot::from_raw(305398016_u64 as _)
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *const vk::AllocationCallbacks,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkDestroyPrivateDataSlot = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkDestroyPrivateDataSlot, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkDestroyPrivateDataSlot", erased);
		let resolutions = Fixture::query_count();
		vk::destroy_private_data_slot(
			&fixture.device,
			vk::PrivateDataSlot::from_raw(305398016_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::AllocationCallbacks,
		)
		.unwrap();
		vk::Device::destroy_private_data_slot(
			&fixture.device,
			vk::PrivateDataSlot::from_raw(305398016_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::AllocationCallbacks,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn destroy_private_data_slot_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::PrivateDataSlot,
		*const vk::AllocationCallbacks,
	) -> Result<(), CallError>;
	let _: Signature = vk::destroy_private_data_slot_ext;
	let _: Signature = vk::Device::destroy_private_data_slot_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::destroy_private_data_slot_ext(
				&fixture.device,
				std::mem::zeroed::<vk::PrivateDataSlot>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>()
			),
			Err(CallError::MissingCommand("vkDestroyPrivateDataSlotEXT"))
		));
		assert!(matches!(
			fixture.device.destroy_private_data_slot_ext(
				std::mem::zeroed::<vk::PrivateDataSlot>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>()
			),
			Err(CallError::MissingCommand("vkDestroyPrivateDataSlotEXT"))
		));
	}
}

#[test]
fn destroy_private_data_slot_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::PrivateDataSlot,
		arg_2: *const vk::AllocationCallbacks,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::PrivateDataSlot::from_raw(305398016_u64 as _)
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *const vk::AllocationCallbacks,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkDestroyPrivateDataSlotEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkDestroyPrivateDataSlotEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkDestroyPrivateDataSlotEXT", erased);
		let resolutions = Fixture::query_count();
		vk::destroy_private_data_slot_ext(
			&fixture.device,
			vk::PrivateDataSlot::from_raw(305398016_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::AllocationCallbacks,
		)
		.unwrap();
		vk::Device::destroy_private_data_slot_ext(
			&fixture.device,
			vk::PrivateDataSlot::from_raw(305398016_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::AllocationCallbacks,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn set_private_data_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::ObjectType,
		u64,
		vk::PrivateDataSlot,
		u64,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::set_private_data;
	let _: Signature = vk::Device::set_private_data;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::set_private_data(
				&fixture.device,
				std::mem::zeroed::<vk::ObjectType>(),
				std::mem::zeroed::<u64>(),
				std::mem::zeroed::<vk::PrivateDataSlot>(),
				std::mem::zeroed::<u64>()
			),
			Err(CallError::MissingCommand("vkSetPrivateData"))
		));
		assert!(matches!(
			fixture.device.set_private_data(
				std::mem::zeroed::<vk::ObjectType>(),
				std::mem::zeroed::<u64>(),
				std::mem::zeroed::<vk::PrivateDataSlot>(),
				std::mem::zeroed::<u64>()
			),
			Err(CallError::MissingCommand("vkSetPrivateData"))
		));
	}
}

#[test]
fn set_private_data_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::ObjectType,
		arg_2: u64,
		arg_3: vk::PrivateDataSlot,
		arg_4: u64,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::ObjectType::from_raw(305398016_u64 as _)
					&& arg_2 == Default::default()
					&& arg_3 == vk::PrivateDataSlot::from_raw(305398528_u64 as _)
					&& arg_4 == Default::default()),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkSetPrivateData = Some(mock);
		let erased = std::mem::transmute::<vk::PFN_vkSetPrivateData, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkSetPrivateData", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::set_private_data(
					&fixture.device,
					vk::ObjectType::from_raw(305398016_u64 as _),
					Default::default(),
					vk::PrivateDataSlot::from_raw(305398528_u64 as _),
					Default::default()
				),
				expected
			);
			assert_eq!(
				vk::Device::set_private_data(
					&fixture.device,
					vk::ObjectType::from_raw(305398016_u64 as _),
					Default::default(),
					vk::PrivateDataSlot::from_raw(305398528_u64 as _),
					Default::default()
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn set_private_data_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::ObjectType,
		u64,
		vk::PrivateDataSlot,
		u64,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::set_private_data_ext;
	let _: Signature = vk::Device::set_private_data_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::set_private_data_ext(
				&fixture.device,
				std::mem::zeroed::<vk::ObjectType>(),
				std::mem::zeroed::<u64>(),
				std::mem::zeroed::<vk::PrivateDataSlot>(),
				std::mem::zeroed::<u64>()
			),
			Err(CallError::MissingCommand("vkSetPrivateDataEXT"))
		));
		assert!(matches!(
			fixture.device.set_private_data_ext(
				std::mem::zeroed::<vk::ObjectType>(),
				std::mem::zeroed::<u64>(),
				std::mem::zeroed::<vk::PrivateDataSlot>(),
				std::mem::zeroed::<u64>()
			),
			Err(CallError::MissingCommand("vkSetPrivateDataEXT"))
		));
	}
}

#[test]
fn set_private_data_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::ObjectType,
		arg_2: u64,
		arg_3: vk::PrivateDataSlot,
		arg_4: u64,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::ObjectType::from_raw(305398016_u64 as _)
					&& arg_2 == Default::default()
					&& arg_3 == vk::PrivateDataSlot::from_raw(305398528_u64 as _)
					&& arg_4 == Default::default()),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkSetPrivateDataEXT = Some(mock);
		let erased = std::mem::transmute::<vk::PFN_vkSetPrivateDataEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkSetPrivateDataEXT", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::set_private_data_ext(
					&fixture.device,
					vk::ObjectType::from_raw(305398016_u64 as _),
					Default::default(),
					vk::PrivateDataSlot::from_raw(305398528_u64 as _),
					Default::default()
				),
				expected
			);
			assert_eq!(
				vk::Device::set_private_data_ext(
					&fixture.device,
					vk::ObjectType::from_raw(305398016_u64 as _),
					Default::default(),
					vk::PrivateDataSlot::from_raw(305398528_u64 as _),
					Default::default()
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_private_data_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::ObjectType,
		u64,
		vk::PrivateDataSlot,
		*mut u64,
	) -> Result<(), CallError>;
	let _: Signature = vk::get_private_data;
	let _: Signature = vk::Device::get_private_data;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_private_data(
				&fixture.device,
				std::mem::zeroed::<vk::ObjectType>(),
				std::mem::zeroed::<u64>(),
				std::mem::zeroed::<vk::PrivateDataSlot>(),
				std::mem::zeroed::<*mut u64>()
			),
			Err(CallError::MissingCommand("vkGetPrivateData"))
		));
		assert!(matches!(
			fixture.device.get_private_data(
				std::mem::zeroed::<vk::ObjectType>(),
				std::mem::zeroed::<u64>(),
				std::mem::zeroed::<vk::PrivateDataSlot>(),
				std::mem::zeroed::<*mut u64>()
			),
			Err(CallError::MissingCommand("vkGetPrivateData"))
		));
	}
}

#[test]
fn get_private_data_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::ObjectType,
		arg_2: u64,
		arg_3: vk::PrivateDataSlot,
		arg_4: *mut u64,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::ObjectType::from_raw(305398016_u64 as _)
					&& arg_2 == Default::default()
					&& arg_3 == vk::PrivateDataSlot::from_raw(305398528_u64 as _)
					&& std::ptr::eq(
						arg_4,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784) as *mut u64,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetPrivateData = Some(mock);
		let erased = std::mem::transmute::<vk::PFN_vkGetPrivateData, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkGetPrivateData", erased);
		let resolutions = Fixture::query_count();
		vk::get_private_data(
			&fixture.device,
			vk::ObjectType::from_raw(305398016_u64 as _),
			Default::default(),
			vk::PrivateDataSlot::from_raw(305398528_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784) as *mut u64,
		)
		.unwrap();
		vk::Device::get_private_data(
			&fixture.device,
			vk::ObjectType::from_raw(305398016_u64 as _),
			Default::default(),
			vk::PrivateDataSlot::from_raw(305398528_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784) as *mut u64,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_private_data_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::ObjectType,
		u64,
		vk::PrivateDataSlot,
		*mut u64,
	) -> Result<(), CallError>;
	let _: Signature = vk::get_private_data_ext;
	let _: Signature = vk::Device::get_private_data_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_private_data_ext(
				&fixture.device,
				std::mem::zeroed::<vk::ObjectType>(),
				std::mem::zeroed::<u64>(),
				std::mem::zeroed::<vk::PrivateDataSlot>(),
				std::mem::zeroed::<*mut u64>()
			),
			Err(CallError::MissingCommand("vkGetPrivateDataEXT"))
		));
		assert!(matches!(
			fixture.device.get_private_data_ext(
				std::mem::zeroed::<vk::ObjectType>(),
				std::mem::zeroed::<u64>(),
				std::mem::zeroed::<vk::PrivateDataSlot>(),
				std::mem::zeroed::<*mut u64>()
			),
			Err(CallError::MissingCommand("vkGetPrivateDataEXT"))
		));
	}
}

#[test]
fn get_private_data_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::ObjectType,
		arg_2: u64,
		arg_3: vk::PrivateDataSlot,
		arg_4: *mut u64,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::ObjectType::from_raw(305398016_u64 as _)
					&& arg_2 == Default::default()
					&& arg_3 == vk::PrivateDataSlot::from_raw(305398528_u64 as _)
					&& std::ptr::eq(
						arg_4,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784) as *mut u64,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetPrivateDataEXT = Some(mock);
		let erased = std::mem::transmute::<vk::PFN_vkGetPrivateDataEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkGetPrivateDataEXT", erased);
		let resolutions = Fixture::query_count();
		vk::get_private_data_ext(
			&fixture.device,
			vk::ObjectType::from_raw(305398016_u64 as _),
			Default::default(),
			vk::PrivateDataSlot::from_raw(305398528_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784) as *mut u64,
		)
		.unwrap();
		vk::Device::get_private_data_ext(
			&fixture.device,
			vk::ObjectType::from_raw(305398016_u64 as _),
			Default::default(),
			vk::PrivateDataSlot::from_raw(305398528_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784) as *mut u64,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_copy_buffer2_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, vk::CommandBuffer, &vk::CopyBufferInfo2<'_>) -> Result<(), CallError>;
	let _: Signature = vk::cmd_copy_buffer2;
	let _: Signature = vk::Device::cmd_copy_buffer2;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_copy_buffer2(
				&fixture.device,
				Default::default(),
				&std::mem::zeroed::<vk::CopyBufferInfo2<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdCopyBuffer2"))
		));
		assert!(matches!(
			fixture.device.cmd_copy_buffer2(
				Default::default(),
				&std::mem::zeroed::<vk::CopyBufferInfo2<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdCopyBuffer2"))
		));
	}
}

#[test]
fn cmd_copy_buffer2_khr_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, vk::CommandBuffer, &vk::CopyBufferInfo2<'_>) -> Result<(), CallError>;
	let _: Signature = vk::cmd_copy_buffer2_khr;
	let _: Signature = vk::Device::cmd_copy_buffer2_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_copy_buffer2_khr(
				&fixture.device,
				Default::default(),
				&std::mem::zeroed::<vk::CopyBufferInfo2<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdCopyBuffer2KHR"))
		));
		assert!(matches!(
			fixture.device.cmd_copy_buffer2_khr(
				Default::default(),
				&std::mem::zeroed::<vk::CopyBufferInfo2<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdCopyBuffer2KHR"))
		));
	}
}

#[test]
fn cmd_copy_image2_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, vk::CommandBuffer, &vk::CopyImageInfo2<'_>) -> Result<(), CallError>;
	let _: Signature = vk::cmd_copy_image2;
	let _: Signature = vk::Device::cmd_copy_image2;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_copy_image2(
				&fixture.device,
				Default::default(),
				&std::mem::zeroed::<vk::CopyImageInfo2<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdCopyImage2"))
		));
		assert!(matches!(
			fixture.device.cmd_copy_image2(
				Default::default(),
				&std::mem::zeroed::<vk::CopyImageInfo2<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdCopyImage2"))
		));
	}
}

#[test]
fn cmd_copy_image2_khr_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, vk::CommandBuffer, &vk::CopyImageInfo2<'_>) -> Result<(), CallError>;
	let _: Signature = vk::cmd_copy_image2_khr;
	let _: Signature = vk::Device::cmd_copy_image2_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_copy_image2_khr(
				&fixture.device,
				Default::default(),
				&std::mem::zeroed::<vk::CopyImageInfo2<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdCopyImage2KHR"))
		));
		assert!(matches!(
			fixture.device.cmd_copy_image2_khr(
				Default::default(),
				&std::mem::zeroed::<vk::CopyImageInfo2<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdCopyImage2KHR"))
		));
	}
}

#[test]
fn cmd_blit_image2_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, vk::CommandBuffer, &vk::BlitImageInfo2<'_>) -> Result<(), CallError>;
	let _: Signature = vk::cmd_blit_image2;
	let _: Signature = vk::Device::cmd_blit_image2;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_blit_image2(
				&fixture.device,
				Default::default(),
				&std::mem::zeroed::<vk::BlitImageInfo2<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdBlitImage2"))
		));
		assert!(matches!(
			fixture.device.cmd_blit_image2(
				Default::default(),
				&std::mem::zeroed::<vk::BlitImageInfo2<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdBlitImage2"))
		));
	}
}

#[test]
fn cmd_blit_image2_khr_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, vk::CommandBuffer, &vk::BlitImageInfo2<'_>) -> Result<(), CallError>;
	let _: Signature = vk::cmd_blit_image2_khr;
	let _: Signature = vk::Device::cmd_blit_image2_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_blit_image2_khr(
				&fixture.device,
				Default::default(),
				&std::mem::zeroed::<vk::BlitImageInfo2<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdBlitImage2KHR"))
		));
		assert!(matches!(
			fixture.device.cmd_blit_image2_khr(
				Default::default(),
				&std::mem::zeroed::<vk::BlitImageInfo2<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdBlitImage2KHR"))
		));
	}
}

#[test]
fn cmd_copy_buffer_to_image2_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		&vk::CopyBufferToImageInfo2<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_copy_buffer_to_image2;
	let _: Signature = vk::Device::cmd_copy_buffer_to_image2;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_copy_buffer_to_image2(
				&fixture.device,
				Default::default(),
				&std::mem::zeroed::<vk::CopyBufferToImageInfo2<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdCopyBufferToImage2"))
		));
		assert!(matches!(
			fixture.device.cmd_copy_buffer_to_image2(
				Default::default(),
				&std::mem::zeroed::<vk::CopyBufferToImageInfo2<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdCopyBufferToImage2"))
		));
	}
}

#[test]
fn cmd_copy_buffer_to_image2_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		&vk::CopyBufferToImageInfo2<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_copy_buffer_to_image2_khr;
	let _: Signature = vk::Device::cmd_copy_buffer_to_image2_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_copy_buffer_to_image2_khr(
				&fixture.device,
				Default::default(),
				&std::mem::zeroed::<vk::CopyBufferToImageInfo2<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdCopyBufferToImage2KHR"))
		));
		assert!(matches!(
			fixture.device.cmd_copy_buffer_to_image2_khr(
				Default::default(),
				&std::mem::zeroed::<vk::CopyBufferToImageInfo2<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdCopyBufferToImage2KHR"))
		));
	}
}

#[test]
fn cmd_copy_image_to_buffer2_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		&vk::CopyImageToBufferInfo2<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_copy_image_to_buffer2;
	let _: Signature = vk::Device::cmd_copy_image_to_buffer2;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_copy_image_to_buffer2(
				&fixture.device,
				Default::default(),
				&std::mem::zeroed::<vk::CopyImageToBufferInfo2<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdCopyImageToBuffer2"))
		));
		assert!(matches!(
			fixture.device.cmd_copy_image_to_buffer2(
				Default::default(),
				&std::mem::zeroed::<vk::CopyImageToBufferInfo2<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdCopyImageToBuffer2"))
		));
	}
}

#[test]
fn cmd_copy_image_to_buffer2_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		&vk::CopyImageToBufferInfo2<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_copy_image_to_buffer2_khr;
	let _: Signature = vk::Device::cmd_copy_image_to_buffer2_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_copy_image_to_buffer2_khr(
				&fixture.device,
				Default::default(),
				&std::mem::zeroed::<vk::CopyImageToBufferInfo2<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdCopyImageToBuffer2KHR"))
		));
		assert!(matches!(
			fixture.device.cmd_copy_image_to_buffer2_khr(
				Default::default(),
				&std::mem::zeroed::<vk::CopyImageToBufferInfo2<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdCopyImageToBuffer2KHR"))
		));
	}
}

#[test]
fn cmd_resolve_image2_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, vk::CommandBuffer, &vk::ResolveImageInfo2<'_>) -> Result<(), CallError>;
	let _: Signature = vk::cmd_resolve_image2;
	let _: Signature = vk::Device::cmd_resolve_image2;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_resolve_image2(
				&fixture.device,
				Default::default(),
				&std::mem::zeroed::<vk::ResolveImageInfo2<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdResolveImage2"))
		));
		assert!(matches!(
			fixture.device.cmd_resolve_image2(
				Default::default(),
				&std::mem::zeroed::<vk::ResolveImageInfo2<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdResolveImage2"))
		));
	}
}

#[test]
fn cmd_resolve_image2_khr_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, vk::CommandBuffer, &vk::ResolveImageInfo2<'_>) -> Result<(), CallError>;
	let _: Signature = vk::cmd_resolve_image2_khr;
	let _: Signature = vk::Device::cmd_resolve_image2_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_resolve_image2_khr(
				&fixture.device,
				Default::default(),
				&std::mem::zeroed::<vk::ResolveImageInfo2<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdResolveImage2KHR"))
		));
		assert!(matches!(
			fixture.device.cmd_resolve_image2_khr(
				Default::default(),
				&std::mem::zeroed::<vk::ResolveImageInfo2<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdResolveImage2KHR"))
		));
	}
}

#[test]
fn cmd_set_fragment_shading_rate_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		*const vk::Extent2D,
		*const vk::FragmentShadingRateCombinerOpKHR,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_fragment_shading_rate_khr;
	let _: Signature = vk::Device::cmd_set_fragment_shading_rate_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_fragment_shading_rate_khr(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::Extent2D>(),
				std::mem::zeroed::<*const vk::FragmentShadingRateCombinerOpKHR>()
			),
			Err(CallError::MissingCommand("vkCmdSetFragmentShadingRateKHR"))
		));
		assert!(matches!(
			fixture.device.cmd_set_fragment_shading_rate_khr(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::Extent2D>(),
				std::mem::zeroed::<*const vk::FragmentShadingRateCombinerOpKHR>()
			),
			Err(CallError::MissingCommand("vkCmdSetFragmentShadingRateKHR"))
		));
	}
}

#[test]
fn cmd_set_fragment_shading_rate_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: *const vk::Extent2D,
		arg_2: *const vk::FragmentShadingRateCombinerOpKHR,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016) as *const vk::Extent2D,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::FragmentShadingRateCombinerOpKHR,
				)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdSetFragmentShadingRateKHR = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdSetFragmentShadingRateKHR, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdSetFragmentShadingRateKHR", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_set_fragment_shading_rate_khr(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016) as *const vk::Extent2D,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::FragmentShadingRateCombinerOpKHR,
		)
		.unwrap();
		vk::Device::cmd_set_fragment_shading_rate_khr(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016) as *const vk::Extent2D,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::FragmentShadingRateCombinerOpKHR,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_physical_device_fragment_shading_rates_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		vk::PhysicalDevice,
		*mut u32,
		*mut vk::PhysicalDeviceFragmentShadingRateKHR<'_>,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_physical_device_fragment_shading_rates_khr;
	let _: Signature = vk::Instance::get_physical_device_fragment_shading_rates_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_physical_device_fragment_shading_rates_khr(
				&fixture.instance,
				std::mem::zeroed::<vk::PhysicalDevice>(),
				std::mem::zeroed::<*mut u32>(),
				std::mem::zeroed::<*mut vk::PhysicalDeviceFragmentShadingRateKHR<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceFragmentShadingRatesKHR"
			))
		));
		assert!(matches!(
			fixture
				.instance
				.get_physical_device_fragment_shading_rates_khr(
					std::mem::zeroed::<vk::PhysicalDevice>(),
					std::mem::zeroed::<*mut u32>(),
					std::mem::zeroed::<*mut vk::PhysicalDeviceFragmentShadingRateKHR<'_>>()
				),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceFragmentShadingRatesKHR"
			))
		));
	}
}

#[test]
fn get_physical_device_fragment_shading_rates_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::PhysicalDevice,
		arg_1: *mut u32,
		arg_2: *mut vk::PhysicalDeviceFragmentShadingRateKHR<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::PhysicalDevice::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016) as *mut u32,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::PhysicalDeviceFragmentShadingRateKHR<'_>,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkGetPhysicalDeviceFragmentShadingRatesKHR", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_physical_device_fragment_shading_rates_khr(
					&fixture.instance,
					vk::PhysicalDevice::from_raw(305397760_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016) as *mut u32,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::PhysicalDeviceFragmentShadingRateKHR<'_>
				),
				expected
			);
			assert_eq!(
				vk::Instance::get_physical_device_fragment_shading_rates_khr(
					&fixture.instance,
					vk::PhysicalDevice::from_raw(305397760_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016) as *mut u32,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::PhysicalDeviceFragmentShadingRateKHR<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_set_fragment_shading_rate_enum_nv_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		vk::FragmentShadingRateNV,
		*const vk::FragmentShadingRateCombinerOpKHR,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_fragment_shading_rate_enum_nv;
	let _: Signature = vk::Device::cmd_set_fragment_shading_rate_enum_nv;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_fragment_shading_rate_enum_nv(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::FragmentShadingRateNV>(),
				std::mem::zeroed::<*const vk::FragmentShadingRateCombinerOpKHR>()
			),
			Err(CallError::MissingCommand(
				"vkCmdSetFragmentShadingRateEnumNV"
			))
		));
		assert!(matches!(
			fixture.device.cmd_set_fragment_shading_rate_enum_nv(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::FragmentShadingRateNV>(),
				std::mem::zeroed::<*const vk::FragmentShadingRateCombinerOpKHR>()
			),
			Err(CallError::MissingCommand(
				"vkCmdSetFragmentShadingRateEnumNV"
			))
		));
	}
}

#[test]
fn cmd_set_fragment_shading_rate_enum_nv_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: vk::FragmentShadingRateNV,
		arg_2: *const vk::FragmentShadingRateCombinerOpKHR,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == vk::FragmentShadingRateNV::from_raw(305398016_u64 as _)
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *const vk::FragmentShadingRateCombinerOpKHR,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdSetFragmentShadingRateEnumNV = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkCmdSetFragmentShadingRateEnumNV,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdSetFragmentShadingRateEnumNV", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_set_fragment_shading_rate_enum_nv(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::FragmentShadingRateNV::from_raw(305398016_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::FragmentShadingRateCombinerOpKHR,
		)
		.unwrap();
		vk::Device::cmd_set_fragment_shading_rate_enum_nv(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::FragmentShadingRateNV::from_raw(305398016_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::FragmentShadingRateCombinerOpKHR,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_acceleration_structure_build_sizes_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::AccelerationStructureBuildTypeKHR,
		*const vk::AccelerationStructureBuildGeometryInfoKHR<'_>,
		*const u32,
		*mut vk::AccelerationStructureBuildSizesInfoKHR<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::get_acceleration_structure_build_sizes_khr;
	let _: Signature = vk::Device::get_acceleration_structure_build_sizes_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_acceleration_structure_build_sizes_khr(
				&fixture.device,
				std::mem::zeroed::<vk::AccelerationStructureBuildTypeKHR>(),
				std::mem::zeroed::<*const vk::AccelerationStructureBuildGeometryInfoKHR<'_>>(),
				std::mem::zeroed::<*const u32>(),
				std::mem::zeroed::<*mut vk::AccelerationStructureBuildSizesInfoKHR<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetAccelerationStructureBuildSizesKHR"
			))
		));
		assert!(matches!(
			fixture.device.get_acceleration_structure_build_sizes_khr(
				std::mem::zeroed::<vk::AccelerationStructureBuildTypeKHR>(),
				std::mem::zeroed::<*const vk::AccelerationStructureBuildGeometryInfoKHR<'_>>(),
				std::mem::zeroed::<*const u32>(),
				std::mem::zeroed::<*mut vk::AccelerationStructureBuildSizesInfoKHR<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetAccelerationStructureBuildSizesKHR"
			))
		));
	}
}

#[test]
fn get_acceleration_structure_build_sizes_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::AccelerationStructureBuildTypeKHR,
		arg_2: *const vk::AccelerationStructureBuildGeometryInfoKHR<'_>,
		arg_3: *const u32,
		arg_4: *mut vk::AccelerationStructureBuildSizesInfoKHR<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::AccelerationStructureBuildTypeKHR::from_raw(305398016_u64 as _)
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *const vk::AccelerationStructureBuildGeometryInfoKHR<'_>,
					) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *const u32,
				) && std::ptr::eq(
					arg_4,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784)
						as *mut vk::AccelerationStructureBuildSizesInfoKHR<'_>,
				)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetAccelerationStructureBuildSizesKHR = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetAccelerationStructureBuildSizesKHR,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkGetAccelerationStructureBuildSizesKHR", erased);
		let resolutions = Fixture::query_count();
		vk::get_acceleration_structure_build_sizes_khr(
			&fixture.device,
			vk::AccelerationStructureBuildTypeKHR::from_raw(305398016_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::AccelerationStructureBuildGeometryInfoKHR<'_>,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *const u32,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784)
				as *mut vk::AccelerationStructureBuildSizesInfoKHR<'_>,
		)
		.unwrap();
		vk::Device::get_acceleration_structure_build_sizes_khr(
			&fixture.device,
			vk::AccelerationStructureBuildTypeKHR::from_raw(305398016_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::AccelerationStructureBuildGeometryInfoKHR<'_>,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *const u32,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784)
				as *mut vk::AccelerationStructureBuildSizesInfoKHR<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_set_vertex_input_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		u32,
		*const vk::VertexInputBindingDescription2EXT<'_>,
		u32,
		*const vk::VertexInputAttributeDescription2EXT<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_vertex_input_ext;
	let _: Signature = vk::Device::cmd_set_vertex_input_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_vertex_input_ext(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::VertexInputBindingDescription2EXT<'_>>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::VertexInputAttributeDescription2EXT<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdSetVertexInputEXT"))
		));
		assert!(matches!(
			fixture.device.cmd_set_vertex_input_ext(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::VertexInputBindingDescription2EXT<'_>>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::VertexInputAttributeDescription2EXT<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdSetVertexInputEXT"))
		));
	}
}

#[test]
fn cmd_set_vertex_input_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: u32,
		arg_2: *const vk::VertexInputBindingDescription2EXT<'_>,
		arg_3: u32,
		arg_4: *const vk::VertexInputAttributeDescription2EXT<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == Default::default()
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *const vk::VertexInputBindingDescription2EXT<'_>,
					) && arg_3 == Default::default()
					&& std::ptr::eq(
						arg_4,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784)
							as *const vk::VertexInputAttributeDescription2EXT<'_>,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdSetVertexInputEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdSetVertexInputEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdSetVertexInputEXT", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_set_vertex_input_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::VertexInputBindingDescription2EXT<'_>,
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784)
				as *const vk::VertexInputAttributeDescription2EXT<'_>,
		)
		.unwrap();
		vk::Device::cmd_set_vertex_input_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::VertexInputBindingDescription2EXT<'_>,
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784)
				as *const vk::VertexInputAttributeDescription2EXT<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_set_color_write_enable_ext_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, vk::CommandBuffer, u32, *const vk::Bool32) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_color_write_enable_ext;
	let _: Signature = vk::Device::cmd_set_color_write_enable_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_color_write_enable_ext(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::Bool32>()
			),
			Err(CallError::MissingCommand("vkCmdSetColorWriteEnableEXT"))
		));
		assert!(matches!(
			fixture.device.cmd_set_color_write_enable_ext(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::Bool32>()
			),
			Err(CallError::MissingCommand("vkCmdSetColorWriteEnableEXT"))
		));
	}
}

#[test]
fn cmd_set_color_write_enable_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::CommandBuffer, arg_1: u32, arg_2: *const vk::Bool32) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == Default::default()
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *const vk::Bool32,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdSetColorWriteEnableEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdSetColorWriteEnableEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdSetColorWriteEnableEXT", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_set_color_write_enable_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *const vk::Bool32,
		)
		.unwrap();
		vk::Device::cmd_set_color_write_enable_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *const vk::Bool32,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_set_event2_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		vk::Event,
		&vk::DependencyInfo<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_event2;
	let _: Signature = vk::Device::cmd_set_event2;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_event2(
				&fixture.device,
				Default::default(),
				Default::default(),
				&std::mem::zeroed::<vk::DependencyInfo<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdSetEvent2"))
		));
		assert!(matches!(
			fixture.device.cmd_set_event2(
				Default::default(),
				Default::default(),
				&std::mem::zeroed::<vk::DependencyInfo<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdSetEvent2"))
		));
	}
}

#[test]
fn cmd_set_event2_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		vk::Event,
		&vk::DependencyInfo<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_event2_khr;
	let _: Signature = vk::Device::cmd_set_event2_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_event2_khr(
				&fixture.device,
				Default::default(),
				Default::default(),
				&std::mem::zeroed::<vk::DependencyInfo<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdSetEvent2KHR"))
		));
		assert!(matches!(
			fixture.device.cmd_set_event2_khr(
				Default::default(),
				Default::default(),
				&std::mem::zeroed::<vk::DependencyInfo<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdSetEvent2KHR"))
		));
	}
}

#[test]
fn cmd_reset_event2_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		vk::Event,
		vk::PipelineStageFlags2,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_reset_event2;
	let _: Signature = vk::Device::cmd_reset_event2;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_reset_event2(
				&fixture.device,
				Default::default(),
				Default::default(),
				Default::default()
			),
			Err(CallError::MissingCommand("vkCmdResetEvent2"))
		));
		assert!(matches!(
			fixture
				.device
				.cmd_reset_event2(Default::default(), Default::default(), Default::default()),
			Err(CallError::MissingCommand("vkCmdResetEvent2"))
		));
	}
}

#[test]
fn cmd_reset_event2_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		vk::Event,
		vk::PipelineStageFlags2,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_reset_event2_khr;
	let _: Signature = vk::Device::cmd_reset_event2_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_reset_event2_khr(
				&fixture.device,
				Default::default(),
				Default::default(),
				Default::default()
			),
			Err(CallError::MissingCommand("vkCmdResetEvent2KHR"))
		));
		assert!(matches!(
			fixture.device.cmd_reset_event2_khr(
				Default::default(),
				Default::default(),
				Default::default()
			),
			Err(CallError::MissingCommand("vkCmdResetEvent2KHR"))
		));
	}
}

#[test]
fn cmd_wait_events2_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		&[vk::Event],
		&[vk::DependencyInfo<'_>],
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_wait_events2;
	let _: Signature = vk::Device::cmd_wait_events2;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_wait_events2(&fixture.device, Default::default(), &[], &[]),
			Err(CallError::MissingCommand("vkCmdWaitEvents2"))
		));
		assert!(matches!(
			fixture
				.device
				.cmd_wait_events2(Default::default(), &[], &[]),
			Err(CallError::MissingCommand("vkCmdWaitEvents2"))
		));
	}
}

#[test]
fn cmd_wait_events2_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		&[vk::Event],
		&[vk::DependencyInfo<'_>],
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_wait_events2_khr;
	let _: Signature = vk::Device::cmd_wait_events2_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_wait_events2_khr(&fixture.device, Default::default(), &[], &[]),
			Err(CallError::MissingCommand("vkCmdWaitEvents2KHR"))
		));
		assert!(matches!(
			fixture
				.device
				.cmd_wait_events2_khr(Default::default(), &[], &[]),
			Err(CallError::MissingCommand("vkCmdWaitEvents2KHR"))
		));
	}
}

#[test]
fn cmd_pipeline_barrier2_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, vk::CommandBuffer, &vk::DependencyInfo<'_>) -> Result<(), CallError>;
	let _: Signature = vk::cmd_pipeline_barrier2;
	let _: Signature = vk::Device::cmd_pipeline_barrier2;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_pipeline_barrier2(
				&fixture.device,
				Default::default(),
				&std::mem::zeroed::<vk::DependencyInfo<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdPipelineBarrier2"))
		));
		assert!(matches!(
			fixture.device.cmd_pipeline_barrier2(
				Default::default(),
				&std::mem::zeroed::<vk::DependencyInfo<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdPipelineBarrier2"))
		));
	}
}

#[test]
fn cmd_pipeline_barrier2_khr_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, vk::CommandBuffer, &vk::DependencyInfo<'_>) -> Result<(), CallError>;
	let _: Signature = vk::cmd_pipeline_barrier2_khr;
	let _: Signature = vk::Device::cmd_pipeline_barrier2_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_pipeline_barrier2_khr(
				&fixture.device,
				Default::default(),
				&std::mem::zeroed::<vk::DependencyInfo<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdPipelineBarrier2KHR"))
		));
		assert!(matches!(
			fixture.device.cmd_pipeline_barrier2_khr(
				Default::default(),
				&std::mem::zeroed::<vk::DependencyInfo<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdPipelineBarrier2KHR"))
		));
	}
}

#[test]
fn queue_submit2_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, vk::Queue, &[vk::SubmitInfo2<'_>], vk::Fence) -> Result<(), CallError>;
	let _: Signature = vk::queue_submit2;
	let _: Signature = vk::Device::queue_submit2;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::queue_submit2(&fixture.device, Default::default(), &[], Default::default()),
			Err(CallError::MissingCommand("vkQueueSubmit2"))
		));
		assert!(matches!(
			fixture
				.device
				.queue_submit2(Default::default(), &[], Default::default()),
			Err(CallError::MissingCommand("vkQueueSubmit2"))
		));
	}
}

#[test]
fn queue_submit2_khr_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, vk::Queue, &[vk::SubmitInfo2<'_>], vk::Fence) -> Result<(), CallError>;
	let _: Signature = vk::queue_submit2_khr;
	let _: Signature = vk::Device::queue_submit2_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::queue_submit2_khr(&fixture.device, Default::default(), &[], Default::default()),
			Err(CallError::MissingCommand("vkQueueSubmit2KHR"))
		));
		assert!(matches!(
			fixture
				.device
				.queue_submit2_khr(Default::default(), &[], Default::default()),
			Err(CallError::MissingCommand("vkQueueSubmit2KHR"))
		));
	}
}

#[test]
fn cmd_write_timestamp2_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		vk::PipelineStageFlags2,
		vk::QueryPool,
		u32,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_write_timestamp2;
	let _: Signature = vk::Device::cmd_write_timestamp2;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_write_timestamp2(
				&fixture.device,
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default()
			),
			Err(CallError::MissingCommand("vkCmdWriteTimestamp2"))
		));
		assert!(matches!(
			fixture.device.cmd_write_timestamp2(
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default()
			),
			Err(CallError::MissingCommand("vkCmdWriteTimestamp2"))
		));
	}
}

#[test]
fn cmd_write_timestamp2_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		vk::PipelineStageFlags2,
		vk::QueryPool,
		u32,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_write_timestamp2_khr;
	let _: Signature = vk::Device::cmd_write_timestamp2_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_write_timestamp2_khr(
				&fixture.device,
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default()
			),
			Err(CallError::MissingCommand("vkCmdWriteTimestamp2KHR"))
		));
		assert!(matches!(
			fixture.device.cmd_write_timestamp2_khr(
				Default::default(),
				Default::default(),
				Default::default(),
				Default::default()
			),
			Err(CallError::MissingCommand("vkCmdWriteTimestamp2KHR"))
		));
	}
}

#[test]
fn cmd_write_buffer_marker2_amd_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		vk::PipelineStageFlags2,
		vk::Buffer,
		vk::DeviceSize,
		u32,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_write_buffer_marker2_amd;
	let _: Signature = vk::Device::cmd_write_buffer_marker2_amd;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_write_buffer_marker2_amd(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::PipelineStageFlags2>(),
				std::mem::zeroed::<vk::Buffer>(),
				std::mem::zeroed::<vk::DeviceSize>(),
				std::mem::zeroed::<u32>()
			),
			Err(CallError::MissingCommand("vkCmdWriteBufferMarker2AMD"))
		));
		assert!(matches!(
			fixture.device.cmd_write_buffer_marker2_amd(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::PipelineStageFlags2>(),
				std::mem::zeroed::<vk::Buffer>(),
				std::mem::zeroed::<vk::DeviceSize>(),
				std::mem::zeroed::<u32>()
			),
			Err(CallError::MissingCommand("vkCmdWriteBufferMarker2AMD"))
		));
	}
}

#[test]
fn cmd_write_buffer_marker2_amd_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: vk::PipelineStageFlags2,
		arg_2: vk::Buffer,
		arg_3: vk::DeviceSize,
		arg_4: u32,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == vk::PipelineStageFlags2::from_raw(305398016_u64 as _)
					&& arg_2 == vk::Buffer::from_raw(305398272_u64 as _)
					&& arg_3 == 305398528_u64 as vk::DeviceSize
					&& arg_4 == Default::default()),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdWriteBufferMarker2AMD = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdWriteBufferMarker2AMD, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdWriteBufferMarker2AMD", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_write_buffer_marker2_amd(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::PipelineStageFlags2::from_raw(305398016_u64 as _),
			vk::Buffer::from_raw(305398272_u64 as _),
			305398528_u64 as vk::DeviceSize,
			Default::default(),
		)
		.unwrap();
		vk::Device::cmd_write_buffer_marker2_amd(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::PipelineStageFlags2::from_raw(305398016_u64 as _),
			vk::Buffer::from_raw(305398272_u64 as _),
			305398528_u64 as vk::DeviceSize,
			Default::default(),
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_queue_checkpoint_data2_nv_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::Queue,
		*mut u32,
		*mut vk::CheckpointData2NV<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::get_queue_checkpoint_data2_nv;
	let _: Signature = vk::Device::get_queue_checkpoint_data2_nv;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_queue_checkpoint_data2_nv(
				&fixture.device,
				std::mem::zeroed::<vk::Queue>(),
				std::mem::zeroed::<*mut u32>(),
				std::mem::zeroed::<*mut vk::CheckpointData2NV<'_>>()
			),
			Err(CallError::MissingCommand("vkGetQueueCheckpointData2NV"))
		));
		assert!(matches!(
			fixture.device.get_queue_checkpoint_data2_nv(
				std::mem::zeroed::<vk::Queue>(),
				std::mem::zeroed::<*mut u32>(),
				std::mem::zeroed::<*mut vk::CheckpointData2NV<'_>>()
			),
			Err(CallError::MissingCommand("vkGetQueueCheckpointData2NV"))
		));
	}
}

#[test]
fn get_queue_checkpoint_data2_nv_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::Queue,
		arg_1: *mut u32,
		arg_2: *mut vk::CheckpointData2NV<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::Queue::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016) as *mut u32,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::CheckpointData2NV<'_>,
				)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetQueueCheckpointData2NV = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkGetQueueCheckpointData2NV, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkGetQueueCheckpointData2NV", erased);
		let resolutions = Fixture::query_count();
		vk::get_queue_checkpoint_data2_nv(
			&fixture.device,
			vk::Queue::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016) as *mut u32,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *mut vk::CheckpointData2NV<'_>,
		)
		.unwrap();
		vk::Device::get_queue_checkpoint_data2_nv(
			&fixture.device,
			vk::Queue::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016) as *mut u32,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *mut vk::CheckpointData2NV<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn copy_memory_to_image_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, *const vk::CopyMemoryToImageInfo<'_>) -> Result<vk::Result, CallError>;
	let _: Signature = vk::copy_memory_to_image;
	let _: Signature = vk::Device::copy_memory_to_image;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::copy_memory_to_image(
				&fixture.device,
				std::mem::zeroed::<*const vk::CopyMemoryToImageInfo<'_>>()
			),
			Err(CallError::MissingCommand("vkCopyMemoryToImage"))
		));
		assert!(matches!(
			fixture
				.device
				.copy_memory_to_image(std::mem::zeroed::<*const vk::CopyMemoryToImageInfo<'_>>()),
			Err(CallError::MissingCommand("vkCopyMemoryToImage"))
		));
	}
}

#[test]
fn copy_memory_to_image_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::CopyMemoryToImageInfo<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::CopyMemoryToImageInfo<'_>,
					)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCopyMemoryToImage = Some(mock);
		let erased = std::mem::transmute::<vk::PFN_vkCopyMemoryToImage, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCopyMemoryToImage", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::copy_memory_to_image(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::CopyMemoryToImageInfo<'_>
				),
				expected
			);
			assert_eq!(
				vk::Device::copy_memory_to_image(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::CopyMemoryToImageInfo<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn copy_memory_to_image_ext_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, *const vk::CopyMemoryToImageInfo<'_>) -> Result<vk::Result, CallError>;
	let _: Signature = vk::copy_memory_to_image_ext;
	let _: Signature = vk::Device::copy_memory_to_image_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::copy_memory_to_image_ext(
				&fixture.device,
				std::mem::zeroed::<*const vk::CopyMemoryToImageInfo<'_>>()
			),
			Err(CallError::MissingCommand("vkCopyMemoryToImageEXT"))
		));
		assert!(matches!(
			fixture
				.device
				.copy_memory_to_image_ext(std::mem::zeroed::<*const vk::CopyMemoryToImageInfo<'_>>()),
			Err(CallError::MissingCommand("vkCopyMemoryToImageEXT"))
		));
	}
}

#[test]
fn copy_memory_to_image_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::CopyMemoryToImageInfo<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::CopyMemoryToImageInfo<'_>,
					)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCopyMemoryToImageEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCopyMemoryToImageEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCopyMemoryToImageEXT", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::copy_memory_to_image_ext(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::CopyMemoryToImageInfo<'_>
				),
				expected
			);
			assert_eq!(
				vk::Device::copy_memory_to_image_ext(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::CopyMemoryToImageInfo<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn copy_image_to_memory_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, *const vk::CopyImageToMemoryInfo<'_>) -> Result<vk::Result, CallError>;
	let _: Signature = vk::copy_image_to_memory;
	let _: Signature = vk::Device::copy_image_to_memory;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::copy_image_to_memory(
				&fixture.device,
				std::mem::zeroed::<*const vk::CopyImageToMemoryInfo<'_>>()
			),
			Err(CallError::MissingCommand("vkCopyImageToMemory"))
		));
		assert!(matches!(
			fixture
				.device
				.copy_image_to_memory(std::mem::zeroed::<*const vk::CopyImageToMemoryInfo<'_>>()),
			Err(CallError::MissingCommand("vkCopyImageToMemory"))
		));
	}
}

#[test]
fn copy_image_to_memory_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::CopyImageToMemoryInfo<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::CopyImageToMemoryInfo<'_>,
					)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCopyImageToMemory = Some(mock);
		let erased = std::mem::transmute::<vk::PFN_vkCopyImageToMemory, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCopyImageToMemory", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::copy_image_to_memory(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::CopyImageToMemoryInfo<'_>
				),
				expected
			);
			assert_eq!(
				vk::Device::copy_image_to_memory(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::CopyImageToMemoryInfo<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn copy_image_to_memory_ext_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, *const vk::CopyImageToMemoryInfo<'_>) -> Result<vk::Result, CallError>;
	let _: Signature = vk::copy_image_to_memory_ext;
	let _: Signature = vk::Device::copy_image_to_memory_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::copy_image_to_memory_ext(
				&fixture.device,
				std::mem::zeroed::<*const vk::CopyImageToMemoryInfo<'_>>()
			),
			Err(CallError::MissingCommand("vkCopyImageToMemoryEXT"))
		));
		assert!(matches!(
			fixture
				.device
				.copy_image_to_memory_ext(std::mem::zeroed::<*const vk::CopyImageToMemoryInfo<'_>>()),
			Err(CallError::MissingCommand("vkCopyImageToMemoryEXT"))
		));
	}
}

#[test]
fn copy_image_to_memory_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::CopyImageToMemoryInfo<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::CopyImageToMemoryInfo<'_>,
					)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCopyImageToMemoryEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCopyImageToMemoryEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCopyImageToMemoryEXT", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::copy_image_to_memory_ext(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::CopyImageToMemoryInfo<'_>
				),
				expected
			);
			assert_eq!(
				vk::Device::copy_image_to_memory_ext(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::CopyImageToMemoryInfo<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn copy_image_to_image_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, *const vk::CopyImageToImageInfo<'_>) -> Result<vk::Result, CallError>;
	let _: Signature = vk::copy_image_to_image;
	let _: Signature = vk::Device::copy_image_to_image;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::copy_image_to_image(
				&fixture.device,
				std::mem::zeroed::<*const vk::CopyImageToImageInfo<'_>>()
			),
			Err(CallError::MissingCommand("vkCopyImageToImage"))
		));
		assert!(matches!(
			fixture
				.device
				.copy_image_to_image(std::mem::zeroed::<*const vk::CopyImageToImageInfo<'_>>()),
			Err(CallError::MissingCommand("vkCopyImageToImage"))
		));
	}
}

#[test]
fn copy_image_to_image_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::CopyImageToImageInfo<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::CopyImageToImageInfo<'_>,
					)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCopyImageToImage = Some(mock);
		let erased = std::mem::transmute::<vk::PFN_vkCopyImageToImage, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCopyImageToImage", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::copy_image_to_image(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::CopyImageToImageInfo<'_>
				),
				expected
			);
			assert_eq!(
				vk::Device::copy_image_to_image(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::CopyImageToImageInfo<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn copy_image_to_image_ext_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, *const vk::CopyImageToImageInfo<'_>) -> Result<vk::Result, CallError>;
	let _: Signature = vk::copy_image_to_image_ext;
	let _: Signature = vk::Device::copy_image_to_image_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::copy_image_to_image_ext(
				&fixture.device,
				std::mem::zeroed::<*const vk::CopyImageToImageInfo<'_>>()
			),
			Err(CallError::MissingCommand("vkCopyImageToImageEXT"))
		));
		assert!(matches!(
			fixture
				.device
				.copy_image_to_image_ext(std::mem::zeroed::<*const vk::CopyImageToImageInfo<'_>>()),
			Err(CallError::MissingCommand("vkCopyImageToImageEXT"))
		));
	}
}

#[test]
fn copy_image_to_image_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::CopyImageToImageInfo<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::CopyImageToImageInfo<'_>,
					)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCopyImageToImageEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCopyImageToImageEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCopyImageToImageEXT", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::copy_image_to_image_ext(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::CopyImageToImageInfo<'_>
				),
				expected
			);
			assert_eq!(
				vk::Device::copy_image_to_image_ext(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::CopyImageToImageInfo<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn transition_image_layout_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		u32,
		*const vk::HostImageLayoutTransitionInfo<'_>,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::transition_image_layout;
	let _: Signature = vk::Device::transition_image_layout;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::transition_image_layout(
				&fixture.device,
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::HostImageLayoutTransitionInfo<'_>>()
			),
			Err(CallError::MissingCommand("vkTransitionImageLayout"))
		));
		assert!(matches!(
			fixture.device.transition_image_layout(
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::HostImageLayoutTransitionInfo<'_>>()
			),
			Err(CallError::MissingCommand("vkTransitionImageLayout"))
		));
	}
}

#[test]
fn transition_image_layout_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: u32,
		arg_2: *const vk::HostImageLayoutTransitionInfo<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == Default::default()
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *const vk::HostImageLayoutTransitionInfo<'_>,
					)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkTransitionImageLayout = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkTransitionImageLayout, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkTransitionImageLayout", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::transition_image_layout(
					&fixture.device,
					Default::default(),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::HostImageLayoutTransitionInfo<'_>
				),
				expected
			);
			assert_eq!(
				vk::Device::transition_image_layout(
					&fixture.device,
					Default::default(),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::HostImageLayoutTransitionInfo<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn transition_image_layout_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		u32,
		*const vk::HostImageLayoutTransitionInfo<'_>,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::transition_image_layout_ext;
	let _: Signature = vk::Device::transition_image_layout_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::transition_image_layout_ext(
				&fixture.device,
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::HostImageLayoutTransitionInfo<'_>>()
			),
			Err(CallError::MissingCommand("vkTransitionImageLayoutEXT"))
		));
		assert!(matches!(
			fixture.device.transition_image_layout_ext(
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::HostImageLayoutTransitionInfo<'_>>()
			),
			Err(CallError::MissingCommand("vkTransitionImageLayoutEXT"))
		));
	}
}

#[test]
fn transition_image_layout_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: u32,
		arg_2: *const vk::HostImageLayoutTransitionInfo<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == Default::default()
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *const vk::HostImageLayoutTransitionInfo<'_>,
					)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkTransitionImageLayoutEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkTransitionImageLayoutEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkTransitionImageLayoutEXT", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::transition_image_layout_ext(
					&fixture.device,
					Default::default(),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::HostImageLayoutTransitionInfo<'_>
				),
				expected
			);
			assert_eq!(
				vk::Device::transition_image_layout_ext(
					&fixture.device,
					Default::default(),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::HostImageLayoutTransitionInfo<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_physical_device_video_capabilities_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		vk::PhysicalDevice,
		*const vk::VideoProfileInfoKHR<'_>,
		*mut vk::VideoCapabilitiesKHR<'_>,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_physical_device_video_capabilities_khr;
	let _: Signature = vk::Instance::get_physical_device_video_capabilities_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_physical_device_video_capabilities_khr(
				&fixture.instance,
				std::mem::zeroed::<vk::PhysicalDevice>(),
				std::mem::zeroed::<*const vk::VideoProfileInfoKHR<'_>>(),
				std::mem::zeroed::<*mut vk::VideoCapabilitiesKHR<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceVideoCapabilitiesKHR"
			))
		));
		assert!(matches!(
			fixture.instance.get_physical_device_video_capabilities_khr(
				std::mem::zeroed::<vk::PhysicalDevice>(),
				std::mem::zeroed::<*const vk::VideoProfileInfoKHR<'_>>(),
				std::mem::zeroed::<*mut vk::VideoCapabilitiesKHR<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceVideoCapabilitiesKHR"
			))
		));
	}
}

#[test]
fn get_physical_device_video_capabilities_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::PhysicalDevice,
		arg_1: *const vk::VideoProfileInfoKHR<'_>,
		arg_2: *mut vk::VideoCapabilitiesKHR<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::PhysicalDevice::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::VideoProfileInfoKHR<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::VideoCapabilitiesKHR<'_>,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkGetPhysicalDeviceVideoCapabilitiesKHR", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_physical_device_video_capabilities_khr(
					&fixture.instance,
					vk::PhysicalDevice::from_raw(305397760_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::VideoProfileInfoKHR<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::VideoCapabilitiesKHR<'_>
				),
				expected
			);
			assert_eq!(
				vk::Instance::get_physical_device_video_capabilities_khr(
					&fixture.instance,
					vk::PhysicalDevice::from_raw(305397760_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::VideoProfileInfoKHR<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::VideoCapabilitiesKHR<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_physical_device_video_format_properties_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		vk::PhysicalDevice,
		*const vk::PhysicalDeviceVideoFormatInfoKHR<'_>,
		*mut u32,
		*mut vk::VideoFormatPropertiesKHR<'_>,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_physical_device_video_format_properties_khr;
	let _: Signature = vk::Instance::get_physical_device_video_format_properties_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_physical_device_video_format_properties_khr(
				&fixture.instance,
				std::mem::zeroed::<vk::PhysicalDevice>(),
				std::mem::zeroed::<*const vk::PhysicalDeviceVideoFormatInfoKHR<'_>>(),
				std::mem::zeroed::<*mut u32>(),
				std::mem::zeroed::<*mut vk::VideoFormatPropertiesKHR<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceVideoFormatPropertiesKHR"
			))
		));
		assert!(matches!(
			fixture
				.instance
				.get_physical_device_video_format_properties_khr(
					std::mem::zeroed::<vk::PhysicalDevice>(),
					std::mem::zeroed::<*const vk::PhysicalDeviceVideoFormatInfoKHR<'_>>(),
					std::mem::zeroed::<*mut u32>(),
					std::mem::zeroed::<*mut vk::VideoFormatPropertiesKHR<'_>>()
				),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceVideoFormatPropertiesKHR"
			))
		));
	}
}

#[test]
fn get_physical_device_video_format_properties_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::PhysicalDevice,
		arg_1: *const vk::PhysicalDeviceVideoFormatInfoKHR<'_>,
		arg_2: *mut u32,
		arg_3: *mut vk::VideoFormatPropertiesKHR<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::PhysicalDevice::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::PhysicalDeviceVideoFormatInfoKHR<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut u32,
				) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::VideoFormatPropertiesKHR<'_>,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetPhysicalDeviceVideoFormatPropertiesKHR = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetPhysicalDeviceVideoFormatPropertiesKHR,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkGetPhysicalDeviceVideoFormatPropertiesKHR", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_physical_device_video_format_properties_khr(
					&fixture.instance,
					vk::PhysicalDevice::from_raw(305397760_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::PhysicalDeviceVideoFormatInfoKHR<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut u32,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::VideoFormatPropertiesKHR<'_>
				),
				expected
			);
			assert_eq!(
				vk::Instance::get_physical_device_video_format_properties_khr(
					&fixture.instance,
					vk::PhysicalDevice::from_raw(305397760_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::PhysicalDeviceVideoFormatInfoKHR<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut u32,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::VideoFormatPropertiesKHR<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_physical_device_video_encode_quality_level_properties_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		vk::PhysicalDevice,
		*const vk::PhysicalDeviceVideoEncodeQualityLevelInfoKHR<'_>,
		*mut vk::VideoEncodeQualityLevelPropertiesKHR<'_>,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_physical_device_video_encode_quality_level_properties_khr;
	let _: Signature = vk::Instance::get_physical_device_video_encode_quality_level_properties_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_physical_device_video_encode_quality_level_properties_khr(
				&fixture.instance,
				std::mem::zeroed::<vk::PhysicalDevice>(),
				std::mem::zeroed::<*const vk::PhysicalDeviceVideoEncodeQualityLevelInfoKHR<'_>>(),
				std::mem::zeroed::<*mut vk::VideoEncodeQualityLevelPropertiesKHR<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR"
			))
		));
		assert!(matches!(
			fixture
				.instance
				.get_physical_device_video_encode_quality_level_properties_khr(
					std::mem::zeroed::<vk::PhysicalDevice>(),
					std::mem::zeroed::<*const vk::PhysicalDeviceVideoEncodeQualityLevelInfoKHR<'_>>(),
					std::mem::zeroed::<*mut vk::VideoEncodeQualityLevelPropertiesKHR<'_>>()
				),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR"
			))
		));
	}
}

#[test]
fn get_physical_device_video_encode_quality_level_properties_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::PhysicalDevice,
		arg_1: *const vk::PhysicalDeviceVideoEncodeQualityLevelInfoKHR<'_>,
		arg_2: *mut vk::VideoEncodeQualityLevelPropertiesKHR<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::PhysicalDevice::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::PhysicalDeviceVideoEncodeQualityLevelInfoKHR<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::VideoEncodeQualityLevelPropertiesKHR<'_>,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(
			c"vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR",
			erased,
		);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_physical_device_video_encode_quality_level_properties_khr(
					&fixture.instance,
					vk::PhysicalDevice::from_raw(305397760_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::PhysicalDeviceVideoEncodeQualityLevelInfoKHR<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::VideoEncodeQualityLevelPropertiesKHR<'_>
				),
				expected
			);
			assert_eq!(
				vk::Instance::get_physical_device_video_encode_quality_level_properties_khr(
					&fixture.instance,
					vk::PhysicalDevice::from_raw(305397760_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::PhysicalDeviceVideoEncodeQualityLevelInfoKHR<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::VideoEncodeQualityLevelPropertiesKHR<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn create_video_session_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::VideoSessionCreateInfoKHR<'_>,
		*const vk::AllocationCallbacks,
		*mut vk::VideoSessionKHR,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::create_video_session_khr;
	let _: Signature = vk::Device::create_video_session_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::create_video_session_khr(
				&fixture.device,
				std::mem::zeroed::<*const vk::VideoSessionCreateInfoKHR<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::VideoSessionKHR>()
			),
			Err(CallError::MissingCommand("vkCreateVideoSessionKHR"))
		));
		assert!(matches!(
			fixture.device.create_video_session_khr(
				std::mem::zeroed::<*const vk::VideoSessionCreateInfoKHR<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::VideoSessionKHR>()
			),
			Err(CallError::MissingCommand("vkCreateVideoSessionKHR"))
		));
	}
}

#[test]
fn create_video_session_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::VideoSessionCreateInfoKHR<'_>,
		arg_2: *const vk::AllocationCallbacks,
		arg_3: *mut vk::VideoSessionKHR,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::VideoSessionCreateInfoKHR<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
				) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::VideoSessionKHR,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCreateVideoSessionKHR = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCreateVideoSessionKHR, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCreateVideoSessionKHR", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::create_video_session_khr(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::VideoSessionCreateInfoKHR<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::VideoSessionKHR
				),
				expected
			);
			assert_eq!(
				vk::Device::create_video_session_khr(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::VideoSessionCreateInfoKHR<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::VideoSessionKHR
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn destroy_video_session_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::VideoSessionKHR,
		*const vk::AllocationCallbacks,
	) -> Result<(), CallError>;
	let _: Signature = vk::destroy_video_session_khr;
	let _: Signature = vk::Device::destroy_video_session_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::destroy_video_session_khr(
				&fixture.device,
				std::mem::zeroed::<vk::VideoSessionKHR>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>()
			),
			Err(CallError::MissingCommand("vkDestroyVideoSessionKHR"))
		));
		assert!(matches!(
			fixture.device.destroy_video_session_khr(
				std::mem::zeroed::<vk::VideoSessionKHR>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>()
			),
			Err(CallError::MissingCommand("vkDestroyVideoSessionKHR"))
		));
	}
}

#[test]
fn destroy_video_session_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::VideoSessionKHR,
		arg_2: *const vk::AllocationCallbacks,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::VideoSessionKHR::from_raw(305398016_u64 as _)
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *const vk::AllocationCallbacks,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkDestroyVideoSessionKHR = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkDestroyVideoSessionKHR, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkDestroyVideoSessionKHR", erased);
		let resolutions = Fixture::query_count();
		vk::destroy_video_session_khr(
			&fixture.device,
			vk::VideoSessionKHR::from_raw(305398016_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::AllocationCallbacks,
		)
		.unwrap();
		vk::Device::destroy_video_session_khr(
			&fixture.device,
			vk::VideoSessionKHR::from_raw(305398016_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::AllocationCallbacks,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn create_video_session_parameters_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::VideoSessionParametersCreateInfoKHR<'_>,
		*const vk::AllocationCallbacks,
		*mut vk::VideoSessionParametersKHR,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::create_video_session_parameters_khr;
	let _: Signature = vk::Device::create_video_session_parameters_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::create_video_session_parameters_khr(
				&fixture.device,
				std::mem::zeroed::<*const vk::VideoSessionParametersCreateInfoKHR<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::VideoSessionParametersKHR>()
			),
			Err(CallError::MissingCommand(
				"vkCreateVideoSessionParametersKHR"
			))
		));
		assert!(matches!(
			fixture.device.create_video_session_parameters_khr(
				std::mem::zeroed::<*const vk::VideoSessionParametersCreateInfoKHR<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::VideoSessionParametersKHR>()
			),
			Err(CallError::MissingCommand(
				"vkCreateVideoSessionParametersKHR"
			))
		));
	}
}

#[test]
fn create_video_session_parameters_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::VideoSessionParametersCreateInfoKHR<'_>,
		arg_2: *const vk::AllocationCallbacks,
		arg_3: *mut vk::VideoSessionParametersKHR,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::VideoSessionParametersCreateInfoKHR<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
				) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::VideoSessionParametersKHR,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCreateVideoSessionParametersKHR = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkCreateVideoSessionParametersKHR,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkCreateVideoSessionParametersKHR", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::create_video_session_parameters_khr(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::VideoSessionParametersCreateInfoKHR<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::VideoSessionParametersKHR
				),
				expected
			);
			assert_eq!(
				vk::Device::create_video_session_parameters_khr(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::VideoSessionParametersCreateInfoKHR<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::VideoSessionParametersKHR
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn update_video_session_parameters_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::VideoSessionParametersKHR,
		*const vk::VideoSessionParametersUpdateInfoKHR<'_>,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::update_video_session_parameters_khr;
	let _: Signature = vk::Device::update_video_session_parameters_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::update_video_session_parameters_khr(
				&fixture.device,
				std::mem::zeroed::<vk::VideoSessionParametersKHR>(),
				std::mem::zeroed::<*const vk::VideoSessionParametersUpdateInfoKHR<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkUpdateVideoSessionParametersKHR"
			))
		));
		assert!(matches!(
			fixture.device.update_video_session_parameters_khr(
				std::mem::zeroed::<vk::VideoSessionParametersKHR>(),
				std::mem::zeroed::<*const vk::VideoSessionParametersUpdateInfoKHR<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkUpdateVideoSessionParametersKHR"
			))
		));
	}
}

#[test]
fn update_video_session_parameters_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::VideoSessionParametersKHR,
		arg_2: *const vk::VideoSessionParametersUpdateInfoKHR<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::VideoSessionParametersKHR::from_raw(305398016_u64 as _)
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *const vk::VideoSessionParametersUpdateInfoKHR<'_>,
					)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkUpdateVideoSessionParametersKHR = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkUpdateVideoSessionParametersKHR,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkUpdateVideoSessionParametersKHR", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::update_video_session_parameters_khr(
					&fixture.device,
					vk::VideoSessionParametersKHR::from_raw(305398016_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::VideoSessionParametersUpdateInfoKHR<'_>
				),
				expected
			);
			assert_eq!(
				vk::Device::update_video_session_parameters_khr(
					&fixture.device,
					vk::VideoSessionParametersKHR::from_raw(305398016_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::VideoSessionParametersUpdateInfoKHR<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_encoded_video_session_parameters_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::VideoEncodeSessionParametersGetInfoKHR<'_>,
		*mut vk::VideoEncodeSessionParametersFeedbackInfoKHR<'_>,
		*mut usize,
		*mut std::ffi::c_void,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_encoded_video_session_parameters_khr;
	let _: Signature = vk::Device::get_encoded_video_session_parameters_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_encoded_video_session_parameters_khr(
				&fixture.device,
				std::mem::zeroed::<*const vk::VideoEncodeSessionParametersGetInfoKHR<'_>>(),
				std::mem::zeroed::<*mut vk::VideoEncodeSessionParametersFeedbackInfoKHR<'_>>(),
				std::mem::zeroed::<*mut usize>(),
				std::mem::zeroed::<*mut std::ffi::c_void>()
			),
			Err(CallError::MissingCommand(
				"vkGetEncodedVideoSessionParametersKHR"
			))
		));
		assert!(matches!(
			fixture.device.get_encoded_video_session_parameters_khr(
				std::mem::zeroed::<*const vk::VideoEncodeSessionParametersGetInfoKHR<'_>>(),
				std::mem::zeroed::<*mut vk::VideoEncodeSessionParametersFeedbackInfoKHR<'_>>(),
				std::mem::zeroed::<*mut usize>(),
				std::mem::zeroed::<*mut std::ffi::c_void>()
			),
			Err(CallError::MissingCommand(
				"vkGetEncodedVideoSessionParametersKHR"
			))
		));
	}
}

#[test]
fn get_encoded_video_session_parameters_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::VideoEncodeSessionParametersGetInfoKHR<'_>,
		arg_2: *mut vk::VideoEncodeSessionParametersFeedbackInfoKHR<'_>,
		arg_3: *mut usize,
		arg_4: *mut std::ffi::c_void,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::VideoEncodeSessionParametersGetInfoKHR<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::VideoEncodeSessionParametersFeedbackInfoKHR<'_>,
				) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut usize,
				) && std::ptr::eq(
					arg_4,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784),
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetEncodedVideoSessionParametersKHR = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetEncodedVideoSessionParametersKHR,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkGetEncodedVideoSessionParametersKHR", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_encoded_video_session_parameters_khr(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::VideoEncodeSessionParametersGetInfoKHR<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::VideoEncodeSessionParametersFeedbackInfoKHR<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut usize,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784)
				),
				expected
			);
			assert_eq!(
				vk::Device::get_encoded_video_session_parameters_khr(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::VideoEncodeSessionParametersGetInfoKHR<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::VideoEncodeSessionParametersFeedbackInfoKHR<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut usize,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784)
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn destroy_video_session_parameters_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::VideoSessionParametersKHR,
		*const vk::AllocationCallbacks,
	) -> Result<(), CallError>;
	let _: Signature = vk::destroy_video_session_parameters_khr;
	let _: Signature = vk::Device::destroy_video_session_parameters_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::destroy_video_session_parameters_khr(
				&fixture.device,
				std::mem::zeroed::<vk::VideoSessionParametersKHR>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>()
			),
			Err(CallError::MissingCommand(
				"vkDestroyVideoSessionParametersKHR"
			))
		));
		assert!(matches!(
			fixture.device.destroy_video_session_parameters_khr(
				std::mem::zeroed::<vk::VideoSessionParametersKHR>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>()
			),
			Err(CallError::MissingCommand(
				"vkDestroyVideoSessionParametersKHR"
			))
		));
	}
}

#[test]
fn destroy_video_session_parameters_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::VideoSessionParametersKHR,
		arg_2: *const vk::AllocationCallbacks,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::VideoSessionParametersKHR::from_raw(305398016_u64 as _)
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *const vk::AllocationCallbacks,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkDestroyVideoSessionParametersKHR = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkDestroyVideoSessionParametersKHR,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkDestroyVideoSessionParametersKHR", erased);
		let resolutions = Fixture::query_count();
		vk::destroy_video_session_parameters_khr(
			&fixture.device,
			vk::VideoSessionParametersKHR::from_raw(305398016_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::AllocationCallbacks,
		)
		.unwrap();
		vk::Device::destroy_video_session_parameters_khr(
			&fixture.device,
			vk::VideoSessionParametersKHR::from_raw(305398016_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::AllocationCallbacks,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_video_session_memory_requirements_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::VideoSessionKHR,
		*mut u32,
		*mut vk::VideoSessionMemoryRequirementsKHR<'_>,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_video_session_memory_requirements_khr;
	let _: Signature = vk::Device::get_video_session_memory_requirements_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_video_session_memory_requirements_khr(
				&fixture.device,
				std::mem::zeroed::<vk::VideoSessionKHR>(),
				std::mem::zeroed::<*mut u32>(),
				std::mem::zeroed::<*mut vk::VideoSessionMemoryRequirementsKHR<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetVideoSessionMemoryRequirementsKHR"
			))
		));
		assert!(matches!(
			fixture.device.get_video_session_memory_requirements_khr(
				std::mem::zeroed::<vk::VideoSessionKHR>(),
				std::mem::zeroed::<*mut u32>(),
				std::mem::zeroed::<*mut vk::VideoSessionMemoryRequirementsKHR<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetVideoSessionMemoryRequirementsKHR"
			))
		));
	}
}

#[test]
fn get_video_session_memory_requirements_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::VideoSessionKHR,
		arg_2: *mut u32,
		arg_3: *mut vk::VideoSessionMemoryRequirementsKHR<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::VideoSessionKHR::from_raw(305398016_u64 as _)
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut u32,
					) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::VideoSessionMemoryRequirementsKHR<'_>,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetVideoSessionMemoryRequirementsKHR = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetVideoSessionMemoryRequirementsKHR,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkGetVideoSessionMemoryRequirementsKHR", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_video_session_memory_requirements_khr(
					&fixture.device,
					vk::VideoSessionKHR::from_raw(305398016_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut u32,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::VideoSessionMemoryRequirementsKHR<'_>
				),
				expected
			);
			assert_eq!(
				vk::Device::get_video_session_memory_requirements_khr(
					&fixture.device,
					vk::VideoSessionKHR::from_raw(305398016_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut u32,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::VideoSessionMemoryRequirementsKHR<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn bind_video_session_memory_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::VideoSessionKHR,
		u32,
		*const vk::BindVideoSessionMemoryInfoKHR<'_>,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::bind_video_session_memory_khr;
	let _: Signature = vk::Device::bind_video_session_memory_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::bind_video_session_memory_khr(
				&fixture.device,
				std::mem::zeroed::<vk::VideoSessionKHR>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::BindVideoSessionMemoryInfoKHR<'_>>()
			),
			Err(CallError::MissingCommand("vkBindVideoSessionMemoryKHR"))
		));
		assert!(matches!(
			fixture.device.bind_video_session_memory_khr(
				std::mem::zeroed::<vk::VideoSessionKHR>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::BindVideoSessionMemoryInfoKHR<'_>>()
			),
			Err(CallError::MissingCommand("vkBindVideoSessionMemoryKHR"))
		));
	}
}

#[test]
fn bind_video_session_memory_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::VideoSessionKHR,
		arg_2: u32,
		arg_3: *const vk::BindVideoSessionMemoryInfoKHR<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::VideoSessionKHR::from_raw(305398016_u64 as _)
					&& arg_2 == Default::default()
					&& std::ptr::eq(
						arg_3,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
							as *const vk::BindVideoSessionMemoryInfoKHR<'_>,
					)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkBindVideoSessionMemoryKHR = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkBindVideoSessionMemoryKHR, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkBindVideoSessionMemoryKHR", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::bind_video_session_memory_khr(
					&fixture.device,
					vk::VideoSessionKHR::from_raw(305398016_u64 as _),
					Default::default(),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *const vk::BindVideoSessionMemoryInfoKHR<'_>
				),
				expected
			);
			assert_eq!(
				vk::Device::bind_video_session_memory_khr(
					&fixture.device,
					vk::VideoSessionKHR::from_raw(305398016_u64 as _),
					Default::default(),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *const vk::BindVideoSessionMemoryInfoKHR<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_decode_video_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		*const vk::VideoDecodeInfoKHR<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_decode_video_khr;
	let _: Signature = vk::Device::cmd_decode_video_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_decode_video_khr(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::VideoDecodeInfoKHR<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdDecodeVideoKHR"))
		));
		assert!(matches!(
			fixture.device.cmd_decode_video_khr(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::VideoDecodeInfoKHR<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdDecodeVideoKHR"))
		));
	}
}

#[test]
fn cmd_decode_video_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: *const vk::VideoDecodeInfoKHR<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::VideoDecodeInfoKHR<'_>,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdDecodeVideoKHR = Some(mock);
		let erased = std::mem::transmute::<vk::PFN_vkCmdDecodeVideoKHR, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdDecodeVideoKHR", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_decode_video_khr(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::VideoDecodeInfoKHR<'_>,
		)
		.unwrap();
		vk::Device::cmd_decode_video_khr(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::VideoDecodeInfoKHR<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_begin_video_coding_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		*const vk::VideoBeginCodingInfoKHR<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_begin_video_coding_khr;
	let _: Signature = vk::Device::cmd_begin_video_coding_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_begin_video_coding_khr(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::VideoBeginCodingInfoKHR<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdBeginVideoCodingKHR"))
		));
		assert!(matches!(
			fixture.device.cmd_begin_video_coding_khr(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::VideoBeginCodingInfoKHR<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdBeginVideoCodingKHR"))
		));
	}
}

#[test]
fn cmd_begin_video_coding_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: *const vk::VideoBeginCodingInfoKHR<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::VideoBeginCodingInfoKHR<'_>,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdBeginVideoCodingKHR = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdBeginVideoCodingKHR, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdBeginVideoCodingKHR", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_begin_video_coding_khr(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::VideoBeginCodingInfoKHR<'_>,
		)
		.unwrap();
		vk::Device::cmd_begin_video_coding_khr(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::VideoBeginCodingInfoKHR<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_control_video_coding_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		*const vk::VideoCodingControlInfoKHR<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_control_video_coding_khr;
	let _: Signature = vk::Device::cmd_control_video_coding_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_control_video_coding_khr(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::VideoCodingControlInfoKHR<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdControlVideoCodingKHR"))
		));
		assert!(matches!(
			fixture.device.cmd_control_video_coding_khr(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::VideoCodingControlInfoKHR<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdControlVideoCodingKHR"))
		));
	}
}

#[test]
fn cmd_control_video_coding_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: *const vk::VideoCodingControlInfoKHR<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::VideoCodingControlInfoKHR<'_>,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdControlVideoCodingKHR = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdControlVideoCodingKHR, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdControlVideoCodingKHR", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_control_video_coding_khr(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::VideoCodingControlInfoKHR<'_>,
		)
		.unwrap();
		vk::Device::cmd_control_video_coding_khr(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::VideoCodingControlInfoKHR<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_end_video_coding_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		*const vk::VideoEndCodingInfoKHR<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_end_video_coding_khr;
	let _: Signature = vk::Device::cmd_end_video_coding_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_end_video_coding_khr(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::VideoEndCodingInfoKHR<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdEndVideoCodingKHR"))
		));
		assert!(matches!(
			fixture.device.cmd_end_video_coding_khr(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::VideoEndCodingInfoKHR<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdEndVideoCodingKHR"))
		));
	}
}

#[test]
fn cmd_end_video_coding_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: *const vk::VideoEndCodingInfoKHR<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::VideoEndCodingInfoKHR<'_>,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdEndVideoCodingKHR = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdEndVideoCodingKHR, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdEndVideoCodingKHR", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_end_video_coding_khr(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::VideoEndCodingInfoKHR<'_>,
		)
		.unwrap();
		vk::Device::cmd_end_video_coding_khr(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::VideoEndCodingInfoKHR<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_encode_video_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		*const vk::VideoEncodeInfoKHR<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_encode_video_khr;
	let _: Signature = vk::Device::cmd_encode_video_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_encode_video_khr(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::VideoEncodeInfoKHR<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdEncodeVideoKHR"))
		));
		assert!(matches!(
			fixture.device.cmd_encode_video_khr(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::VideoEncodeInfoKHR<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdEncodeVideoKHR"))
		));
	}
}

#[test]
fn cmd_encode_video_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: *const vk::VideoEncodeInfoKHR<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::VideoEncodeInfoKHR<'_>,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdEncodeVideoKHR = Some(mock);
		let erased = std::mem::transmute::<vk::PFN_vkCmdEncodeVideoKHR, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdEncodeVideoKHR", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_encode_video_khr(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::VideoEncodeInfoKHR<'_>,
		)
		.unwrap();
		vk::Device::cmd_encode_video_khr(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::VideoEncodeInfoKHR<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_decompress_memory_nv_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		u32,
		*const vk::DecompressMemoryRegionNV,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_decompress_memory_nv;
	let _: Signature = vk::Device::cmd_decompress_memory_nv;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_decompress_memory_nv(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::DecompressMemoryRegionNV>()
			),
			Err(CallError::MissingCommand("vkCmdDecompressMemoryNV"))
		));
		assert!(matches!(
			fixture.device.cmd_decompress_memory_nv(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::DecompressMemoryRegionNV>()
			),
			Err(CallError::MissingCommand("vkCmdDecompressMemoryNV"))
		));
	}
}

#[test]
fn cmd_decompress_memory_nv_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: u32,
		arg_2: *const vk::DecompressMemoryRegionNV,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == Default::default()
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *const vk::DecompressMemoryRegionNV,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdDecompressMemoryNV = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdDecompressMemoryNV, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdDecompressMemoryNV", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_decompress_memory_nv(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::DecompressMemoryRegionNV,
		)
		.unwrap();
		vk::Device::cmd_decompress_memory_nv(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::DecompressMemoryRegionNV,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_decompress_memory_indirect_count_nv_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		vk::DeviceAddress,
		vk::DeviceAddress,
		u32,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_decompress_memory_indirect_count_nv;
	let _: Signature = vk::Device::cmd_decompress_memory_indirect_count_nv;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_decompress_memory_indirect_count_nv(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::DeviceAddress>(),
				std::mem::zeroed::<vk::DeviceAddress>(),
				std::mem::zeroed::<u32>()
			),
			Err(CallError::MissingCommand(
				"vkCmdDecompressMemoryIndirectCountNV"
			))
		));
		assert!(matches!(
			fixture.device.cmd_decompress_memory_indirect_count_nv(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::DeviceAddress>(),
				std::mem::zeroed::<vk::DeviceAddress>(),
				std::mem::zeroed::<u32>()
			),
			Err(CallError::MissingCommand(
				"vkCmdDecompressMemoryIndirectCountNV"
			))
		));
	}
}

#[test]
fn cmd_decompress_memory_indirect_count_nv_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: vk::DeviceAddress,
		arg_2: vk::DeviceAddress,
		arg_3: u32,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == 305398016_u64 as vk::DeviceAddress
					&& arg_2 == 305398272_u64 as vk::DeviceAddress
					&& arg_3 == Default::default()),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdDecompressMemoryIndirectCountNV = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkCmdDecompressMemoryIndirectCountNV,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdDecompressMemoryIndirectCountNV", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_decompress_memory_indirect_count_nv(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			305398016_u64 as vk::DeviceAddress,
			305398272_u64 as vk::DeviceAddress,
			Default::default(),
		)
		.unwrap();
		vk::Device::cmd_decompress_memory_indirect_count_nv(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			305398016_u64 as vk::DeviceAddress,
			305398272_u64 as vk::DeviceAddress,
			Default::default(),
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_partitioned_acceleration_structures_build_sizes_nv_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::PartitionedAccelerationStructureInstancesInputNV<'_>,
		*mut vk::AccelerationStructureBuildSizesInfoKHR<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::get_partitioned_acceleration_structures_build_sizes_nv;
	let _: Signature = vk::Device::get_partitioned_acceleration_structures_build_sizes_nv;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_partitioned_acceleration_structures_build_sizes_nv(
				&fixture.device,
				std::mem::zeroed::<*const vk::PartitionedAccelerationStructureInstancesInputNV<'_>>(),
				std::mem::zeroed::<*mut vk::AccelerationStructureBuildSizesInfoKHR<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetPartitionedAccelerationStructuresBuildSizesNV"
			))
		));
		assert!(matches!(
			fixture
				.device
				.get_partitioned_acceleration_structures_build_sizes_nv(
					std::mem::zeroed::<*const vk::PartitionedAccelerationStructureInstancesInputNV<'_>>(),
					std::mem::zeroed::<*mut vk::AccelerationStructureBuildSizesInfoKHR<'_>>()
				),
			Err(CallError::MissingCommand(
				"vkGetPartitionedAccelerationStructuresBuildSizesNV"
			))
		));
	}
}

#[test]
fn get_partitioned_acceleration_structures_build_sizes_nv_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::PartitionedAccelerationStructureInstancesInputNV<'_>,
		arg_2: *mut vk::AccelerationStructureBuildSizesInfoKHR<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::PartitionedAccelerationStructureInstancesInputNV<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::AccelerationStructureBuildSizesInfoKHR<'_>,
				)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetPartitionedAccelerationStructuresBuildSizesNV = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetPartitionedAccelerationStructuresBuildSizesNV,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(
			c"vkGetPartitionedAccelerationStructuresBuildSizesNV",
			erased,
		);
		let resolutions = Fixture::query_count();
		vk::get_partitioned_acceleration_structures_build_sizes_nv(
			&fixture.device,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::PartitionedAccelerationStructureInstancesInputNV<'_>,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *mut vk::AccelerationStructureBuildSizesInfoKHR<'_>,
		)
		.unwrap();
		vk::Device::get_partitioned_acceleration_structures_build_sizes_nv(
			&fixture.device,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::PartitionedAccelerationStructureInstancesInputNV<'_>,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *mut vk::AccelerationStructureBuildSizesInfoKHR<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_build_partitioned_acceleration_structures_nv_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		*const vk::BuildPartitionedAccelerationStructureInfoNV<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_build_partitioned_acceleration_structures_nv;
	let _: Signature = vk::Device::cmd_build_partitioned_acceleration_structures_nv;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_build_partitioned_acceleration_structures_nv(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::BuildPartitionedAccelerationStructureInfoNV<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkCmdBuildPartitionedAccelerationStructuresNV"
			))
		));
		assert!(matches!(
			fixture
				.device
				.cmd_build_partitioned_acceleration_structures_nv(
					std::mem::zeroed::<vk::CommandBuffer>(),
					std::mem::zeroed::<*const vk::BuildPartitionedAccelerationStructureInfoNV<'_>>()
				),
			Err(CallError::MissingCommand(
				"vkCmdBuildPartitionedAccelerationStructuresNV"
			))
		));
	}
}

#[test]
fn cmd_build_partitioned_acceleration_structures_nv_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: *const vk::BuildPartitionedAccelerationStructureInfoNV<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::BuildPartitionedAccelerationStructureInfoNV<'_>,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdBuildPartitionedAccelerationStructuresNV = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkCmdBuildPartitionedAccelerationStructuresNV,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture =
			Fixture::new_with_command(c"vkCmdBuildPartitionedAccelerationStructuresNV", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_build_partitioned_acceleration_structures_nv(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::BuildPartitionedAccelerationStructureInfoNV<'_>,
		)
		.unwrap();
		vk::Device::cmd_build_partitioned_acceleration_structures_nv(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::BuildPartitionedAccelerationStructureInfoNV<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_decompress_memory_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		*const vk::DecompressMemoryInfoEXT<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_decompress_memory_ext;
	let _: Signature = vk::Device::cmd_decompress_memory_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_decompress_memory_ext(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::DecompressMemoryInfoEXT<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdDecompressMemoryEXT"))
		));
		assert!(matches!(
			fixture.device.cmd_decompress_memory_ext(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::DecompressMemoryInfoEXT<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdDecompressMemoryEXT"))
		));
	}
}

#[test]
fn cmd_decompress_memory_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: *const vk::DecompressMemoryInfoEXT<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::DecompressMemoryInfoEXT<'_>,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdDecompressMemoryEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdDecompressMemoryEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdDecompressMemoryEXT", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_decompress_memory_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::DecompressMemoryInfoEXT<'_>,
		)
		.unwrap();
		vk::Device::cmd_decompress_memory_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::DecompressMemoryInfoEXT<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_decompress_memory_indirect_count_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		vk::MemoryDecompressionMethodFlagsEXT,
		vk::DeviceAddress,
		vk::DeviceAddress,
		u32,
		u32,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_decompress_memory_indirect_count_ext;
	let _: Signature = vk::Device::cmd_decompress_memory_indirect_count_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_decompress_memory_indirect_count_ext(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::MemoryDecompressionMethodFlagsEXT>(),
				std::mem::zeroed::<vk::DeviceAddress>(),
				std::mem::zeroed::<vk::DeviceAddress>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>()
			),
			Err(CallError::MissingCommand(
				"vkCmdDecompressMemoryIndirectCountEXT"
			))
		));
		assert!(matches!(
			fixture.device.cmd_decompress_memory_indirect_count_ext(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::MemoryDecompressionMethodFlagsEXT>(),
				std::mem::zeroed::<vk::DeviceAddress>(),
				std::mem::zeroed::<vk::DeviceAddress>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>()
			),
			Err(CallError::MissingCommand(
				"vkCmdDecompressMemoryIndirectCountEXT"
			))
		));
	}
}

#[test]
fn cmd_decompress_memory_indirect_count_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: vk::MemoryDecompressionMethodFlagsEXT,
		arg_2: vk::DeviceAddress,
		arg_3: vk::DeviceAddress,
		arg_4: u32,
		arg_5: u32,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == vk::MemoryDecompressionMethodFlagsEXT::from_raw(305398016_u64 as _)
					&& arg_2 == 305398272_u64 as vk::DeviceAddress
					&& arg_3 == 305398528_u64 as vk::DeviceAddress
					&& arg_4 == Default::default()
					&& arg_5 == Default::default()),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdDecompressMemoryIndirectCountEXT = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkCmdDecompressMemoryIndirectCountEXT,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdDecompressMemoryIndirectCountEXT", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_decompress_memory_indirect_count_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::MemoryDecompressionMethodFlagsEXT::from_raw(305398016_u64 as _),
			305398272_u64 as vk::DeviceAddress,
			305398528_u64 as vk::DeviceAddress,
			Default::default(),
			Default::default(),
		)
		.unwrap();
		vk::Device::cmd_decompress_memory_indirect_count_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::MemoryDecompressionMethodFlagsEXT::from_raw(305398016_u64 as _),
			305398272_u64 as vk::DeviceAddress,
			305398528_u64 as vk::DeviceAddress,
			Default::default(),
			Default::default(),
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn create_cu_module_nvx_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::CuModuleCreateInfoNVX<'_>,
		*const vk::AllocationCallbacks,
		*mut vk::CuModuleNVX,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::create_cu_module_nvx;
	let _: Signature = vk::Device::create_cu_module_nvx;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::create_cu_module_nvx(
				&fixture.device,
				std::mem::zeroed::<*const vk::CuModuleCreateInfoNVX<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::CuModuleNVX>()
			),
			Err(CallError::MissingCommand("vkCreateCuModuleNVX"))
		));
		assert!(matches!(
			fixture.device.create_cu_module_nvx(
				std::mem::zeroed::<*const vk::CuModuleCreateInfoNVX<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::CuModuleNVX>()
			),
			Err(CallError::MissingCommand("vkCreateCuModuleNVX"))
		));
	}
}

#[test]
fn create_cu_module_nvx_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::CuModuleCreateInfoNVX<'_>,
		arg_2: *const vk::AllocationCallbacks,
		arg_3: *mut vk::CuModuleNVX,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::CuModuleCreateInfoNVX<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
				) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::CuModuleNVX,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCreateCuModuleNVX = Some(mock);
		let erased = std::mem::transmute::<vk::PFN_vkCreateCuModuleNVX, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCreateCuModuleNVX", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::create_cu_module_nvx(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::CuModuleCreateInfoNVX<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::CuModuleNVX
				),
				expected
			);
			assert_eq!(
				vk::Device::create_cu_module_nvx(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::CuModuleCreateInfoNVX<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::CuModuleNVX
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn create_cu_function_nvx_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::CuFunctionCreateInfoNVX<'_>,
		*const vk::AllocationCallbacks,
		*mut vk::CuFunctionNVX,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::create_cu_function_nvx;
	let _: Signature = vk::Device::create_cu_function_nvx;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::create_cu_function_nvx(
				&fixture.device,
				std::mem::zeroed::<*const vk::CuFunctionCreateInfoNVX<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::CuFunctionNVX>()
			),
			Err(CallError::MissingCommand("vkCreateCuFunctionNVX"))
		));
		assert!(matches!(
			fixture.device.create_cu_function_nvx(
				std::mem::zeroed::<*const vk::CuFunctionCreateInfoNVX<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::CuFunctionNVX>()
			),
			Err(CallError::MissingCommand("vkCreateCuFunctionNVX"))
		));
	}
}

#[test]
fn create_cu_function_nvx_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::CuFunctionCreateInfoNVX<'_>,
		arg_2: *const vk::AllocationCallbacks,
		arg_3: *mut vk::CuFunctionNVX,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::CuFunctionCreateInfoNVX<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
				) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::CuFunctionNVX,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCreateCuFunctionNVX = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCreateCuFunctionNVX, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCreateCuFunctionNVX", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::create_cu_function_nvx(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::CuFunctionCreateInfoNVX<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::CuFunctionNVX
				),
				expected
			);
			assert_eq!(
				vk::Device::create_cu_function_nvx(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::CuFunctionCreateInfoNVX<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::CuFunctionNVX
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn destroy_cu_module_nvx_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CuModuleNVX,
		*const vk::AllocationCallbacks,
	) -> Result<(), CallError>;
	let _: Signature = vk::destroy_cu_module_nvx;
	let _: Signature = vk::Device::destroy_cu_module_nvx;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::destroy_cu_module_nvx(
				&fixture.device,
				std::mem::zeroed::<vk::CuModuleNVX>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>()
			),
			Err(CallError::MissingCommand("vkDestroyCuModuleNVX"))
		));
		assert!(matches!(
			fixture.device.destroy_cu_module_nvx(
				std::mem::zeroed::<vk::CuModuleNVX>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>()
			),
			Err(CallError::MissingCommand("vkDestroyCuModuleNVX"))
		));
	}
}

#[test]
fn destroy_cu_module_nvx_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::CuModuleNVX,
		arg_2: *const vk::AllocationCallbacks,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::CuModuleNVX::from_raw(305398016_u64 as _)
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *const vk::AllocationCallbacks,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkDestroyCuModuleNVX = Some(mock);
		let erased = std::mem::transmute::<vk::PFN_vkDestroyCuModuleNVX, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkDestroyCuModuleNVX", erased);
		let resolutions = Fixture::query_count();
		vk::destroy_cu_module_nvx(
			&fixture.device,
			vk::CuModuleNVX::from_raw(305398016_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::AllocationCallbacks,
		)
		.unwrap();
		vk::Device::destroy_cu_module_nvx(
			&fixture.device,
			vk::CuModuleNVX::from_raw(305398016_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::AllocationCallbacks,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn destroy_cu_function_nvx_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CuFunctionNVX,
		*const vk::AllocationCallbacks,
	) -> Result<(), CallError>;
	let _: Signature = vk::destroy_cu_function_nvx;
	let _: Signature = vk::Device::destroy_cu_function_nvx;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::destroy_cu_function_nvx(
				&fixture.device,
				std::mem::zeroed::<vk::CuFunctionNVX>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>()
			),
			Err(CallError::MissingCommand("vkDestroyCuFunctionNVX"))
		));
		assert!(matches!(
			fixture.device.destroy_cu_function_nvx(
				std::mem::zeroed::<vk::CuFunctionNVX>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>()
			),
			Err(CallError::MissingCommand("vkDestroyCuFunctionNVX"))
		));
	}
}

#[test]
fn destroy_cu_function_nvx_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::CuFunctionNVX,
		arg_2: *const vk::AllocationCallbacks,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::CuFunctionNVX::from_raw(305398016_u64 as _)
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *const vk::AllocationCallbacks,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkDestroyCuFunctionNVX = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkDestroyCuFunctionNVX, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkDestroyCuFunctionNVX", erased);
		let resolutions = Fixture::query_count();
		vk::destroy_cu_function_nvx(
			&fixture.device,
			vk::CuFunctionNVX::from_raw(305398016_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::AllocationCallbacks,
		)
		.unwrap();
		vk::Device::destroy_cu_function_nvx(
			&fixture.device,
			vk::CuFunctionNVX::from_raw(305398016_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::AllocationCallbacks,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_cu_launch_kernel_nvx_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		*const vk::CuLaunchInfoNVX<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_cu_launch_kernel_nvx;
	let _: Signature = vk::Device::cmd_cu_launch_kernel_nvx;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_cu_launch_kernel_nvx(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::CuLaunchInfoNVX<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdCuLaunchKernelNVX"))
		));
		assert!(matches!(
			fixture.device.cmd_cu_launch_kernel_nvx(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::CuLaunchInfoNVX<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdCuLaunchKernelNVX"))
		));
	}
}

#[test]
fn cmd_cu_launch_kernel_nvx_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::CommandBuffer, arg_1: *const vk::CuLaunchInfoNVX<'_>) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::CuLaunchInfoNVX<'_>,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdCuLaunchKernelNVX = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdCuLaunchKernelNVX, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdCuLaunchKernelNVX", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_cu_launch_kernel_nvx(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::CuLaunchInfoNVX<'_>,
		)
		.unwrap();
		vk::Device::cmd_cu_launch_kernel_nvx(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::CuLaunchInfoNVX<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_descriptor_set_layout_size_ext_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, vk::DescriptorSetLayout, *mut vk::DeviceSize) -> Result<(), CallError>;
	let _: Signature = vk::get_descriptor_set_layout_size_ext;
	let _: Signature = vk::Device::get_descriptor_set_layout_size_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_descriptor_set_layout_size_ext(
				&fixture.device,
				std::mem::zeroed::<vk::DescriptorSetLayout>(),
				std::mem::zeroed::<*mut vk::DeviceSize>()
			),
			Err(CallError::MissingCommand("vkGetDescriptorSetLayoutSizeEXT"))
		));
		assert!(matches!(
			fixture.device.get_descriptor_set_layout_size_ext(
				std::mem::zeroed::<vk::DescriptorSetLayout>(),
				std::mem::zeroed::<*mut vk::DeviceSize>()
			),
			Err(CallError::MissingCommand("vkGetDescriptorSetLayoutSizeEXT"))
		));
	}
}

#[test]
fn get_descriptor_set_layout_size_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::DescriptorSetLayout,
		arg_2: *mut vk::DeviceSize,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::DescriptorSetLayout::from_raw(305398016_u64 as _)
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut vk::DeviceSize,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetDescriptorSetLayoutSizeEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkGetDescriptorSetLayoutSizeEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkGetDescriptorSetLayoutSizeEXT", erased);
		let resolutions = Fixture::query_count();
		vk::get_descriptor_set_layout_size_ext(
			&fixture.device,
			vk::DescriptorSetLayout::from_raw(305398016_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut vk::DeviceSize,
		)
		.unwrap();
		vk::Device::get_descriptor_set_layout_size_ext(
			&fixture.device,
			vk::DescriptorSetLayout::from_raw(305398016_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut vk::DeviceSize,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_descriptor_set_layout_binding_offset_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::DescriptorSetLayout,
		u32,
		*mut vk::DeviceSize,
	) -> Result<(), CallError>;
	let _: Signature = vk::get_descriptor_set_layout_binding_offset_ext;
	let _: Signature = vk::Device::get_descriptor_set_layout_binding_offset_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_descriptor_set_layout_binding_offset_ext(
				&fixture.device,
				std::mem::zeroed::<vk::DescriptorSetLayout>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*mut vk::DeviceSize>()
			),
			Err(CallError::MissingCommand(
				"vkGetDescriptorSetLayoutBindingOffsetEXT"
			))
		));
		assert!(matches!(
			fixture.device.get_descriptor_set_layout_binding_offset_ext(
				std::mem::zeroed::<vk::DescriptorSetLayout>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*mut vk::DeviceSize>()
			),
			Err(CallError::MissingCommand(
				"vkGetDescriptorSetLayoutBindingOffsetEXT"
			))
		));
	}
}

#[test]
fn get_descriptor_set_layout_binding_offset_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::DescriptorSetLayout,
		arg_2: u32,
		arg_3: *mut vk::DeviceSize,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::DescriptorSetLayout::from_raw(305398016_u64 as _)
					&& arg_2 == Default::default()
					&& std::ptr::eq(
						arg_3,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::DeviceSize,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetDescriptorSetLayoutBindingOffsetEXT = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetDescriptorSetLayoutBindingOffsetEXT,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkGetDescriptorSetLayoutBindingOffsetEXT", erased);
		let resolutions = Fixture::query_count();
		vk::get_descriptor_set_layout_binding_offset_ext(
			&fixture.device,
			vk::DescriptorSetLayout::from_raw(305398016_u64 as _),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::DeviceSize,
		)
		.unwrap();
		vk::Device::get_descriptor_set_layout_binding_offset_ext(
			&fixture.device,
			vk::DescriptorSetLayout::from_raw(305398016_u64 as _),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::DeviceSize,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_descriptor_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::DescriptorGetInfoEXT<'_>,
		usize,
		*mut std::ffi::c_void,
	) -> Result<(), CallError>;
	let _: Signature = vk::get_descriptor_ext;
	let _: Signature = vk::Device::get_descriptor_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_descriptor_ext(
				&fixture.device,
				std::mem::zeroed::<*const vk::DescriptorGetInfoEXT<'_>>(),
				std::mem::zeroed::<usize>(),
				std::mem::zeroed::<*mut std::ffi::c_void>()
			),
			Err(CallError::MissingCommand("vkGetDescriptorEXT"))
		));
		assert!(matches!(
			fixture.device.get_descriptor_ext(
				std::mem::zeroed::<*const vk::DescriptorGetInfoEXT<'_>>(),
				std::mem::zeroed::<usize>(),
				std::mem::zeroed::<*mut std::ffi::c_void>()
			),
			Err(CallError::MissingCommand("vkGetDescriptorEXT"))
		));
	}
}

#[test]
fn get_descriptor_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::DescriptorGetInfoEXT<'_>,
		arg_2: usize,
		arg_3: *mut std::ffi::c_void,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::DescriptorGetInfoEXT<'_>,
					) && arg_2 == Default::default()
					&& std::ptr::eq(
						arg_3,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528),
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetDescriptorEXT = Some(mock);
		let erased = std::mem::transmute::<vk::PFN_vkGetDescriptorEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkGetDescriptorEXT", erased);
		let resolutions = Fixture::query_count();
		vk::get_descriptor_ext(
			&fixture.device,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::DescriptorGetInfoEXT<'_>,
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528),
		)
		.unwrap();
		vk::Device::get_descriptor_ext(
			&fixture.device,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::DescriptorGetInfoEXT<'_>,
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528),
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_bind_descriptor_buffers_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		u32,
		*const vk::DescriptorBufferBindingInfoEXT<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_bind_descriptor_buffers_ext;
	let _: Signature = vk::Device::cmd_bind_descriptor_buffers_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_bind_descriptor_buffers_ext(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::DescriptorBufferBindingInfoEXT<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdBindDescriptorBuffersEXT"))
		));
		assert!(matches!(
			fixture.device.cmd_bind_descriptor_buffers_ext(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::DescriptorBufferBindingInfoEXT<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdBindDescriptorBuffersEXT"))
		));
	}
}

#[test]
fn cmd_bind_descriptor_buffers_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: u32,
		arg_2: *const vk::DescriptorBufferBindingInfoEXT<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == Default::default()
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *const vk::DescriptorBufferBindingInfoEXT<'_>,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdBindDescriptorBuffersEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdBindDescriptorBuffersEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdBindDescriptorBuffersEXT", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_bind_descriptor_buffers_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::DescriptorBufferBindingInfoEXT<'_>,
		)
		.unwrap();
		vk::Device::cmd_bind_descriptor_buffers_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::DescriptorBufferBindingInfoEXT<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_set_descriptor_buffer_offsets_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		vk::PipelineBindPoint,
		vk::PipelineLayout,
		u32,
		u32,
		*const u32,
		*const vk::DeviceSize,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_descriptor_buffer_offsets_ext;
	let _: Signature = vk::Device::cmd_set_descriptor_buffer_offsets_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_descriptor_buffer_offsets_ext(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::PipelineBindPoint>(),
				std::mem::zeroed::<vk::PipelineLayout>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const u32>(),
				std::mem::zeroed::<*const vk::DeviceSize>()
			),
			Err(CallError::MissingCommand(
				"vkCmdSetDescriptorBufferOffsetsEXT"
			))
		));
		assert!(matches!(
			fixture.device.cmd_set_descriptor_buffer_offsets_ext(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::PipelineBindPoint>(),
				std::mem::zeroed::<vk::PipelineLayout>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const u32>(),
				std::mem::zeroed::<*const vk::DeviceSize>()
			),
			Err(CallError::MissingCommand(
				"vkCmdSetDescriptorBufferOffsetsEXT"
			))
		));
	}
}

#[test]
fn cmd_set_descriptor_buffer_offsets_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: vk::PipelineBindPoint,
		arg_2: vk::PipelineLayout,
		arg_3: u32,
		arg_4: u32,
		arg_5: *const u32,
		arg_6: *const vk::DeviceSize,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == vk::PipelineBindPoint::from_raw(305398016_u64 as _)
					&& arg_2 == vk::PipelineLayout::from_raw(305398272_u64 as _)
					&& arg_3 == Default::default()
					&& arg_4 == Default::default()
					&& std::ptr::eq(
						arg_5,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305399040) as *const u32,
					) && std::ptr::eq(
					arg_6,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305399296) as *const vk::DeviceSize,
				)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdSetDescriptorBufferOffsetsEXT = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkCmdSetDescriptorBufferOffsetsEXT,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdSetDescriptorBufferOffsetsEXT", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_set_descriptor_buffer_offsets_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::PipelineBindPoint::from_raw(305398016_u64 as _),
			vk::PipelineLayout::from_raw(305398272_u64 as _),
			Default::default(),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305399040) as *const u32,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305399296) as *const vk::DeviceSize,
		)
		.unwrap();
		vk::Device::cmd_set_descriptor_buffer_offsets_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::PipelineBindPoint::from_raw(305398016_u64 as _),
			vk::PipelineLayout::from_raw(305398272_u64 as _),
			Default::default(),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305399040) as *const u32,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305399296) as *const vk::DeviceSize,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_bind_descriptor_buffer_embedded_samplers_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		vk::PipelineBindPoint,
		vk::PipelineLayout,
		u32,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_bind_descriptor_buffer_embedded_samplers_ext;
	let _: Signature = vk::Device::cmd_bind_descriptor_buffer_embedded_samplers_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_bind_descriptor_buffer_embedded_samplers_ext(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::PipelineBindPoint>(),
				std::mem::zeroed::<vk::PipelineLayout>(),
				std::mem::zeroed::<u32>()
			),
			Err(CallError::MissingCommand(
				"vkCmdBindDescriptorBufferEmbeddedSamplersEXT"
			))
		));
		assert!(matches!(
			fixture
				.device
				.cmd_bind_descriptor_buffer_embedded_samplers_ext(
					std::mem::zeroed::<vk::CommandBuffer>(),
					std::mem::zeroed::<vk::PipelineBindPoint>(),
					std::mem::zeroed::<vk::PipelineLayout>(),
					std::mem::zeroed::<u32>()
				),
			Err(CallError::MissingCommand(
				"vkCmdBindDescriptorBufferEmbeddedSamplersEXT"
			))
		));
	}
}

#[test]
fn cmd_bind_descriptor_buffer_embedded_samplers_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: vk::PipelineBindPoint,
		arg_2: vk::PipelineLayout,
		arg_3: u32,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == vk::PipelineBindPoint::from_raw(305398016_u64 as _)
					&& arg_2 == vk::PipelineLayout::from_raw(305398272_u64 as _)
					&& arg_3 == Default::default()),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdBindDescriptorBufferEmbeddedSamplersEXT = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkCmdBindDescriptorBufferEmbeddedSamplersEXT,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture =
			Fixture::new_with_command(c"vkCmdBindDescriptorBufferEmbeddedSamplersEXT", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_bind_descriptor_buffer_embedded_samplers_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::PipelineBindPoint::from_raw(305398016_u64 as _),
			vk::PipelineLayout::from_raw(305398272_u64 as _),
			Default::default(),
		)
		.unwrap();
		vk::Device::cmd_bind_descriptor_buffer_embedded_samplers_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::PipelineBindPoint::from_raw(305398016_u64 as _),
			vk::PipelineLayout::from_raw(305398272_u64 as _),
			Default::default(),
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_buffer_opaque_capture_descriptor_data_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::BufferCaptureDescriptorDataInfoEXT<'_>,
		*mut std::ffi::c_void,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_buffer_opaque_capture_descriptor_data_ext;
	let _: Signature = vk::Device::get_buffer_opaque_capture_descriptor_data_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_buffer_opaque_capture_descriptor_data_ext(
				&fixture.device,
				std::mem::zeroed::<*const vk::BufferCaptureDescriptorDataInfoEXT<'_>>(),
				std::mem::zeroed::<*mut std::ffi::c_void>()
			),
			Err(CallError::MissingCommand(
				"vkGetBufferOpaqueCaptureDescriptorDataEXT"
			))
		));
		assert!(matches!(
			fixture
				.device
				.get_buffer_opaque_capture_descriptor_data_ext(
					std::mem::zeroed::<*const vk::BufferCaptureDescriptorDataInfoEXT<'_>>(),
					std::mem::zeroed::<*mut std::ffi::c_void>()
				),
			Err(CallError::MissingCommand(
				"vkGetBufferOpaqueCaptureDescriptorDataEXT"
			))
		));
	}
}

#[test]
fn get_buffer_opaque_capture_descriptor_data_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::BufferCaptureDescriptorDataInfoEXT<'_>,
		arg_2: *mut std::ffi::c_void,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::BufferCaptureDescriptorDataInfoEXT<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272),
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetBufferOpaqueCaptureDescriptorDataEXT = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetBufferOpaqueCaptureDescriptorDataEXT,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkGetBufferOpaqueCaptureDescriptorDataEXT", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_buffer_opaque_capture_descriptor_data_ext(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::BufferCaptureDescriptorDataInfoEXT<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				),
				expected
			);
			assert_eq!(
				vk::Device::get_buffer_opaque_capture_descriptor_data_ext(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::BufferCaptureDescriptorDataInfoEXT<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_image_opaque_capture_descriptor_data_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::ImageCaptureDescriptorDataInfoEXT<'_>,
		*mut std::ffi::c_void,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_image_opaque_capture_descriptor_data_ext;
	let _: Signature = vk::Device::get_image_opaque_capture_descriptor_data_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_image_opaque_capture_descriptor_data_ext(
				&fixture.device,
				std::mem::zeroed::<*const vk::ImageCaptureDescriptorDataInfoEXT<'_>>(),
				std::mem::zeroed::<*mut std::ffi::c_void>()
			),
			Err(CallError::MissingCommand(
				"vkGetImageOpaqueCaptureDescriptorDataEXT"
			))
		));
		assert!(matches!(
			fixture.device.get_image_opaque_capture_descriptor_data_ext(
				std::mem::zeroed::<*const vk::ImageCaptureDescriptorDataInfoEXT<'_>>(),
				std::mem::zeroed::<*mut std::ffi::c_void>()
			),
			Err(CallError::MissingCommand(
				"vkGetImageOpaqueCaptureDescriptorDataEXT"
			))
		));
	}
}

#[test]
fn get_image_opaque_capture_descriptor_data_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::ImageCaptureDescriptorDataInfoEXT<'_>,
		arg_2: *mut std::ffi::c_void,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::ImageCaptureDescriptorDataInfoEXT<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272),
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetImageOpaqueCaptureDescriptorDataEXT = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetImageOpaqueCaptureDescriptorDataEXT,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkGetImageOpaqueCaptureDescriptorDataEXT", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_image_opaque_capture_descriptor_data_ext(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::ImageCaptureDescriptorDataInfoEXT<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				),
				expected
			);
			assert_eq!(
				vk::Device::get_image_opaque_capture_descriptor_data_ext(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::ImageCaptureDescriptorDataInfoEXT<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_image_view_opaque_capture_descriptor_data_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::ImageViewCaptureDescriptorDataInfoEXT<'_>,
		*mut std::ffi::c_void,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_image_view_opaque_capture_descriptor_data_ext;
	let _: Signature = vk::Device::get_image_view_opaque_capture_descriptor_data_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_image_view_opaque_capture_descriptor_data_ext(
				&fixture.device,
				std::mem::zeroed::<*const vk::ImageViewCaptureDescriptorDataInfoEXT<'_>>(),
				std::mem::zeroed::<*mut std::ffi::c_void>()
			),
			Err(CallError::MissingCommand(
				"vkGetImageViewOpaqueCaptureDescriptorDataEXT"
			))
		));
		assert!(matches!(
			fixture
				.device
				.get_image_view_opaque_capture_descriptor_data_ext(
					std::mem::zeroed::<*const vk::ImageViewCaptureDescriptorDataInfoEXT<'_>>(),
					std::mem::zeroed::<*mut std::ffi::c_void>()
				),
			Err(CallError::MissingCommand(
				"vkGetImageViewOpaqueCaptureDescriptorDataEXT"
			))
		));
	}
}

#[test]
fn get_image_view_opaque_capture_descriptor_data_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::ImageViewCaptureDescriptorDataInfoEXT<'_>,
		arg_2: *mut std::ffi::c_void,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::ImageViewCaptureDescriptorDataInfoEXT<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272),
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetImageViewOpaqueCaptureDescriptorDataEXT = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetImageViewOpaqueCaptureDescriptorDataEXT,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture =
			Fixture::new_with_command(c"vkGetImageViewOpaqueCaptureDescriptorDataEXT", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_image_view_opaque_capture_descriptor_data_ext(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::ImageViewCaptureDescriptorDataInfoEXT<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				),
				expected
			);
			assert_eq!(
				vk::Device::get_image_view_opaque_capture_descriptor_data_ext(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::ImageViewCaptureDescriptorDataInfoEXT<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_sampler_opaque_capture_descriptor_data_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::SamplerCaptureDescriptorDataInfoEXT<'_>,
		*mut std::ffi::c_void,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_sampler_opaque_capture_descriptor_data_ext;
	let _: Signature = vk::Device::get_sampler_opaque_capture_descriptor_data_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_sampler_opaque_capture_descriptor_data_ext(
				&fixture.device,
				std::mem::zeroed::<*const vk::SamplerCaptureDescriptorDataInfoEXT<'_>>(),
				std::mem::zeroed::<*mut std::ffi::c_void>()
			),
			Err(CallError::MissingCommand(
				"vkGetSamplerOpaqueCaptureDescriptorDataEXT"
			))
		));
		assert!(matches!(
			fixture
				.device
				.get_sampler_opaque_capture_descriptor_data_ext(
					std::mem::zeroed::<*const vk::SamplerCaptureDescriptorDataInfoEXT<'_>>(),
					std::mem::zeroed::<*mut std::ffi::c_void>()
				),
			Err(CallError::MissingCommand(
				"vkGetSamplerOpaqueCaptureDescriptorDataEXT"
			))
		));
	}
}

#[test]
fn get_sampler_opaque_capture_descriptor_data_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::SamplerCaptureDescriptorDataInfoEXT<'_>,
		arg_2: *mut std::ffi::c_void,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::SamplerCaptureDescriptorDataInfoEXT<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272),
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetSamplerOpaqueCaptureDescriptorDataEXT = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetSamplerOpaqueCaptureDescriptorDataEXT,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkGetSamplerOpaqueCaptureDescriptorDataEXT", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_sampler_opaque_capture_descriptor_data_ext(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::SamplerCaptureDescriptorDataInfoEXT<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				),
				expected
			);
			assert_eq!(
				vk::Device::get_sampler_opaque_capture_descriptor_data_ext(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::SamplerCaptureDescriptorDataInfoEXT<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_acceleration_structure_opaque_capture_descriptor_data_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::AccelerationStructureCaptureDescriptorDataInfoEXT<'_>,
		*mut std::ffi::c_void,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_acceleration_structure_opaque_capture_descriptor_data_ext;
	let _: Signature = vk::Device::get_acceleration_structure_opaque_capture_descriptor_data_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_acceleration_structure_opaque_capture_descriptor_data_ext(
				&fixture.device,
				std::mem::zeroed::<*const vk::AccelerationStructureCaptureDescriptorDataInfoEXT<'_>>(),
				std::mem::zeroed::<*mut std::ffi::c_void>()
			),
			Err(CallError::MissingCommand(
				"vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT"
			))
		));
		assert!(matches!(
			fixture
				.device
				.get_acceleration_structure_opaque_capture_descriptor_data_ext(
					std::mem::zeroed::<*const vk::AccelerationStructureCaptureDescriptorDataInfoEXT<'_>>(),
					std::mem::zeroed::<*mut std::ffi::c_void>()
				),
			Err(CallError::MissingCommand(
				"vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT"
			))
		));
	}
}

#[test]
fn get_acceleration_structure_opaque_capture_descriptor_data_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::AccelerationStructureCaptureDescriptorDataInfoEXT<'_>,
		arg_2: *mut std::ffi::c_void,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::AccelerationStructureCaptureDescriptorDataInfoEXT<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272),
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(
			c"vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT",
			erased,
		);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_acceleration_structure_opaque_capture_descriptor_data_ext(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::AccelerationStructureCaptureDescriptorDataInfoEXT<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				),
				expected
			);
			assert_eq!(
				vk::Device::get_acceleration_structure_opaque_capture_descriptor_data_ext(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::AccelerationStructureCaptureDescriptorDataInfoEXT<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn set_device_memory_priority_ext_signature_and_missing_command() {
	type Signature = unsafe fn(&vk::Device, vk::DeviceMemory, f32) -> Result<(), CallError>;
	let _: Signature = vk::set_device_memory_priority_ext;
	let _: Signature = vk::Device::set_device_memory_priority_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::set_device_memory_priority_ext(
				&fixture.device,
				std::mem::zeroed::<vk::DeviceMemory>(),
				std::mem::zeroed::<f32>()
			),
			Err(CallError::MissingCommand("vkSetDeviceMemoryPriorityEXT"))
		));
		assert!(matches!(
			fixture.device.set_device_memory_priority_ext(
				std::mem::zeroed::<vk::DeviceMemory>(),
				std::mem::zeroed::<f32>()
			),
			Err(CallError::MissingCommand("vkSetDeviceMemoryPriorityEXT"))
		));
	}
}

#[test]
fn set_device_memory_priority_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::DeviceHandle, arg_1: vk::DeviceMemory, arg_2: f32) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::DeviceMemory::from_raw(305398016_u64 as _)
					&& arg_2 == Default::default()),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkSetDeviceMemoryPriorityEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkSetDeviceMemoryPriorityEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkSetDeviceMemoryPriorityEXT", erased);
		let resolutions = Fixture::query_count();
		vk::set_device_memory_priority_ext(
			&fixture.device,
			vk::DeviceMemory::from_raw(305398016_u64 as _),
			Default::default(),
		)
		.unwrap();
		vk::Device::set_device_memory_priority_ext(
			&fixture.device,
			vk::DeviceMemory::from_raw(305398016_u64 as _),
			Default::default(),
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn acquire_drm_display_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		vk::PhysicalDevice,
		i32,
		vk::DisplayKHR,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::acquire_drm_display_ext;
	let _: Signature = vk::Instance::acquire_drm_display_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::acquire_drm_display_ext(
				&fixture.instance,
				std::mem::zeroed::<vk::PhysicalDevice>(),
				std::mem::zeroed::<i32>(),
				std::mem::zeroed::<vk::DisplayKHR>()
			),
			Err(CallError::MissingCommand("vkAcquireDrmDisplayEXT"))
		));
		assert!(matches!(
			fixture.instance.acquire_drm_display_ext(
				std::mem::zeroed::<vk::PhysicalDevice>(),
				std::mem::zeroed::<i32>(),
				std::mem::zeroed::<vk::DisplayKHR>()
			),
			Err(CallError::MissingCommand("vkAcquireDrmDisplayEXT"))
		));
	}
}

#[test]
fn acquire_drm_display_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::PhysicalDevice,
		arg_1: i32,
		arg_2: vk::DisplayKHR,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::PhysicalDevice::from_raw(305397760_u64 as _)
					&& arg_1 == Default::default()
					&& arg_2 == vk::DisplayKHR::from_raw(305398272_u64 as _)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkAcquireDrmDisplayEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkAcquireDrmDisplayEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkAcquireDrmDisplayEXT", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::acquire_drm_display_ext(
					&fixture.instance,
					vk::PhysicalDevice::from_raw(305397760_u64 as _),
					Default::default(),
					vk::DisplayKHR::from_raw(305398272_u64 as _)
				),
				expected
			);
			assert_eq!(
				vk::Instance::acquire_drm_display_ext(
					&fixture.instance,
					vk::PhysicalDevice::from_raw(305397760_u64 as _),
					Default::default(),
					vk::DisplayKHR::from_raw(305398272_u64 as _)
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_drm_display_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		vk::PhysicalDevice,
		i32,
		u32,
		*mut vk::DisplayKHR,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_drm_display_ext;
	let _: Signature = vk::Instance::get_drm_display_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_drm_display_ext(
				&fixture.instance,
				std::mem::zeroed::<vk::PhysicalDevice>(),
				std::mem::zeroed::<i32>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*mut vk::DisplayKHR>()
			),
			Err(CallError::MissingCommand("vkGetDrmDisplayEXT"))
		));
		assert!(matches!(
			fixture.instance.get_drm_display_ext(
				std::mem::zeroed::<vk::PhysicalDevice>(),
				std::mem::zeroed::<i32>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*mut vk::DisplayKHR>()
			),
			Err(CallError::MissingCommand("vkGetDrmDisplayEXT"))
		));
	}
}

#[test]
fn get_drm_display_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::PhysicalDevice,
		arg_1: i32,
		arg_2: u32,
		arg_3: *mut vk::DisplayKHR,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::PhysicalDevice::from_raw(305397760_u64 as _)
					&& arg_1 == Default::default()
					&& arg_2 == Default::default()
					&& std::ptr::eq(
						arg_3,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::DisplayKHR,
					)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetDrmDisplayEXT = Some(mock);
		let erased = std::mem::transmute::<vk::PFN_vkGetDrmDisplayEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkGetDrmDisplayEXT", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_drm_display_ext(
					&fixture.instance,
					vk::PhysicalDevice::from_raw(305397760_u64 as _),
					Default::default(),
					Default::default(),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::DisplayKHR
				),
				expected
			);
			assert_eq!(
				vk::Instance::get_drm_display_ext(
					&fixture.instance,
					vk::PhysicalDevice::from_raw(305397760_u64 as _),
					Default::default(),
					Default::default(),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::DisplayKHR
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn wait_for_present2_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::SwapchainKHR,
		*const vk::PresentWait2InfoKHR<'_>,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::wait_for_present2_khr;
	let _: Signature = vk::Device::wait_for_present2_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::wait_for_present2_khr(
				&fixture.device,
				std::mem::zeroed::<vk::SwapchainKHR>(),
				std::mem::zeroed::<*const vk::PresentWait2InfoKHR<'_>>()
			),
			Err(CallError::MissingCommand("vkWaitForPresent2KHR"))
		));
		assert!(matches!(
			fixture.device.wait_for_present2_khr(
				std::mem::zeroed::<vk::SwapchainKHR>(),
				std::mem::zeroed::<*const vk::PresentWait2InfoKHR<'_>>()
			),
			Err(CallError::MissingCommand("vkWaitForPresent2KHR"))
		));
	}
}

#[test]
fn wait_for_present2_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::SwapchainKHR,
		arg_2: *const vk::PresentWait2InfoKHR<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::SwapchainKHR::from_raw(305398016_u64 as _)
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *const vk::PresentWait2InfoKHR<'_>,
					)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkWaitForPresent2KHR = Some(mock);
		let erased = std::mem::transmute::<vk::PFN_vkWaitForPresent2KHR, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkWaitForPresent2KHR", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::wait_for_present2_khr(
					&fixture.device,
					vk::SwapchainKHR::from_raw(305398016_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::PresentWait2InfoKHR<'_>
				),
				expected
			);
			assert_eq!(
				vk::Device::wait_for_present2_khr(
					&fixture.device,
					vk::SwapchainKHR::from_raw(305398016_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::PresentWait2InfoKHR<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn wait_for_present_khr_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, vk::SwapchainKHR, u64, u64) -> Result<vk::Result, CallError>;
	let _: Signature = vk::wait_for_present_khr;
	let _: Signature = vk::Device::wait_for_present_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::wait_for_present_khr(
				&fixture.device,
				std::mem::zeroed::<vk::SwapchainKHR>(),
				std::mem::zeroed::<u64>(),
				std::mem::zeroed::<u64>()
			),
			Err(CallError::MissingCommand("vkWaitForPresentKHR"))
		));
		assert!(matches!(
			fixture.device.wait_for_present_khr(
				std::mem::zeroed::<vk::SwapchainKHR>(),
				std::mem::zeroed::<u64>(),
				std::mem::zeroed::<u64>()
			),
			Err(CallError::MissingCommand("vkWaitForPresentKHR"))
		));
	}
}

#[test]
fn wait_for_present_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::SwapchainKHR,
		arg_2: u64,
		arg_3: u64,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::SwapchainKHR::from_raw(305398016_u64 as _)
					&& arg_2 == Default::default()
					&& arg_3 == Default::default()),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkWaitForPresentKHR = Some(mock);
		let erased = std::mem::transmute::<vk::PFN_vkWaitForPresentKHR, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkWaitForPresentKHR", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::wait_for_present_khr(
					&fixture.device,
					vk::SwapchainKHR::from_raw(305398016_u64 as _),
					Default::default(),
					Default::default()
				),
				expected
			);
			assert_eq!(
				vk::Device::wait_for_present_khr(
					&fixture.device,
					vk::SwapchainKHR::from_raw(305398016_u64 as _),
					Default::default(),
					Default::default()
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[cfg(feature = "platform-fuchsia")]
#[test]
fn create_buffer_collection_fuchsia_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::BufferCollectionCreateInfoFUCHSIA<'_>,
		*const vk::AllocationCallbacks,
		*mut vk::BufferCollectionFUCHSIA,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::create_buffer_collection_fuchsia;
	let _: Signature = vk::Device::create_buffer_collection_fuchsia;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::create_buffer_collection_fuchsia(
				&fixture.device,
				std::mem::zeroed::<*const vk::BufferCollectionCreateInfoFUCHSIA<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::BufferCollectionFUCHSIA>()
			),
			Err(CallError::MissingCommand("vkCreateBufferCollectionFUCHSIA"))
		));
		assert!(matches!(
			fixture.device.create_buffer_collection_fuchsia(
				std::mem::zeroed::<*const vk::BufferCollectionCreateInfoFUCHSIA<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::BufferCollectionFUCHSIA>()
			),
			Err(CallError::MissingCommand("vkCreateBufferCollectionFUCHSIA"))
		));
	}
}

#[cfg(feature = "platform-fuchsia")]
#[test]
fn create_buffer_collection_fuchsia_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::BufferCollectionCreateInfoFUCHSIA<'_>,
		arg_2: *const vk::AllocationCallbacks,
		arg_3: *mut vk::BufferCollectionFUCHSIA,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::BufferCollectionCreateInfoFUCHSIA<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
				) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::BufferCollectionFUCHSIA,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCreateBufferCollectionFUCHSIA = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCreateBufferCollectionFUCHSIA, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCreateBufferCollectionFUCHSIA", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::create_buffer_collection_fuchsia(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::BufferCollectionCreateInfoFUCHSIA<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::BufferCollectionFUCHSIA
				),
				expected
			);
			assert_eq!(
				vk::Device::create_buffer_collection_fuchsia(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::BufferCollectionCreateInfoFUCHSIA<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::BufferCollectionFUCHSIA
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[cfg(feature = "platform-fuchsia")]
#[test]
fn set_buffer_collection_buffer_constraints_fuchsia_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::BufferCollectionFUCHSIA,
		*const vk::BufferConstraintsInfoFUCHSIA<'_>,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::set_buffer_collection_buffer_constraints_fuchsia;
	let _: Signature = vk::Device::set_buffer_collection_buffer_constraints_fuchsia;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::set_buffer_collection_buffer_constraints_fuchsia(
				&fixture.device,
				std::mem::zeroed::<vk::BufferCollectionFUCHSIA>(),
				std::mem::zeroed::<*const vk::BufferConstraintsInfoFUCHSIA<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkSetBufferCollectionBufferConstraintsFUCHSIA"
			))
		));
		assert!(matches!(
			fixture
				.device
				.set_buffer_collection_buffer_constraints_fuchsia(
					std::mem::zeroed::<vk::BufferCollectionFUCHSIA>(),
					std::mem::zeroed::<*const vk::BufferConstraintsInfoFUCHSIA<'_>>()
				),
			Err(CallError::MissingCommand(
				"vkSetBufferCollectionBufferConstraintsFUCHSIA"
			))
		));
	}
}

#[cfg(feature = "platform-fuchsia")]
#[test]
fn set_buffer_collection_buffer_constraints_fuchsia_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::BufferCollectionFUCHSIA,
		arg_2: *const vk::BufferConstraintsInfoFUCHSIA<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::BufferCollectionFUCHSIA::from_raw(305398016_u64 as _)
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *const vk::BufferConstraintsInfoFUCHSIA<'_>,
					)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkSetBufferCollectionBufferConstraintsFUCHSIA = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkSetBufferCollectionBufferConstraintsFUCHSIA,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture =
			Fixture::new_with_command(c"vkSetBufferCollectionBufferConstraintsFUCHSIA", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::set_buffer_collection_buffer_constraints_fuchsia(
					&fixture.device,
					vk::BufferCollectionFUCHSIA::from_raw(305398016_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::BufferConstraintsInfoFUCHSIA<'_>
				),
				expected
			);
			assert_eq!(
				vk::Device::set_buffer_collection_buffer_constraints_fuchsia(
					&fixture.device,
					vk::BufferCollectionFUCHSIA::from_raw(305398016_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::BufferConstraintsInfoFUCHSIA<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[cfg(feature = "platform-fuchsia")]
#[test]
fn set_buffer_collection_image_constraints_fuchsia_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::BufferCollectionFUCHSIA,
		*const vk::ImageConstraintsInfoFUCHSIA<'_>,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::set_buffer_collection_image_constraints_fuchsia;
	let _: Signature = vk::Device::set_buffer_collection_image_constraints_fuchsia;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::set_buffer_collection_image_constraints_fuchsia(
				&fixture.device,
				std::mem::zeroed::<vk::BufferCollectionFUCHSIA>(),
				std::mem::zeroed::<*const vk::ImageConstraintsInfoFUCHSIA<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkSetBufferCollectionImageConstraintsFUCHSIA"
			))
		));
		assert!(matches!(
			fixture
				.device
				.set_buffer_collection_image_constraints_fuchsia(
					std::mem::zeroed::<vk::BufferCollectionFUCHSIA>(),
					std::mem::zeroed::<*const vk::ImageConstraintsInfoFUCHSIA<'_>>()
				),
			Err(CallError::MissingCommand(
				"vkSetBufferCollectionImageConstraintsFUCHSIA"
			))
		));
	}
}

#[cfg(feature = "platform-fuchsia")]
#[test]
fn set_buffer_collection_image_constraints_fuchsia_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::BufferCollectionFUCHSIA,
		arg_2: *const vk::ImageConstraintsInfoFUCHSIA<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::BufferCollectionFUCHSIA::from_raw(305398016_u64 as _)
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *const vk::ImageConstraintsInfoFUCHSIA<'_>,
					)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkSetBufferCollectionImageConstraintsFUCHSIA = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkSetBufferCollectionImageConstraintsFUCHSIA,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture =
			Fixture::new_with_command(c"vkSetBufferCollectionImageConstraintsFUCHSIA", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::set_buffer_collection_image_constraints_fuchsia(
					&fixture.device,
					vk::BufferCollectionFUCHSIA::from_raw(305398016_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::ImageConstraintsInfoFUCHSIA<'_>
				),
				expected
			);
			assert_eq!(
				vk::Device::set_buffer_collection_image_constraints_fuchsia(
					&fixture.device,
					vk::BufferCollectionFUCHSIA::from_raw(305398016_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::ImageConstraintsInfoFUCHSIA<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[cfg(feature = "platform-fuchsia")]
#[test]
fn destroy_buffer_collection_fuchsia_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::BufferCollectionFUCHSIA,
		*const vk::AllocationCallbacks,
	) -> Result<(), CallError>;
	let _: Signature = vk::destroy_buffer_collection_fuchsia;
	let _: Signature = vk::Device::destroy_buffer_collection_fuchsia;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::destroy_buffer_collection_fuchsia(
				&fixture.device,
				std::mem::zeroed::<vk::BufferCollectionFUCHSIA>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>()
			),
			Err(CallError::MissingCommand(
				"vkDestroyBufferCollectionFUCHSIA"
			))
		));
		assert!(matches!(
			fixture.device.destroy_buffer_collection_fuchsia(
				std::mem::zeroed::<vk::BufferCollectionFUCHSIA>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>()
			),
			Err(CallError::MissingCommand(
				"vkDestroyBufferCollectionFUCHSIA"
			))
		));
	}
}

#[cfg(feature = "platform-fuchsia")]
#[test]
fn destroy_buffer_collection_fuchsia_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::BufferCollectionFUCHSIA,
		arg_2: *const vk::AllocationCallbacks,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::BufferCollectionFUCHSIA::from_raw(305398016_u64 as _)
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *const vk::AllocationCallbacks,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkDestroyBufferCollectionFUCHSIA = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkDestroyBufferCollectionFUCHSIA,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkDestroyBufferCollectionFUCHSIA", erased);
		let resolutions = Fixture::query_count();
		vk::destroy_buffer_collection_fuchsia(
			&fixture.device,
			vk::BufferCollectionFUCHSIA::from_raw(305398016_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::AllocationCallbacks,
		)
		.unwrap();
		vk::Device::destroy_buffer_collection_fuchsia(
			&fixture.device,
			vk::BufferCollectionFUCHSIA::from_raw(305398016_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::AllocationCallbacks,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[cfg(feature = "platform-fuchsia")]
#[test]
fn get_buffer_collection_properties_fuchsia_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::BufferCollectionFUCHSIA,
		*mut vk::BufferCollectionPropertiesFUCHSIA<'_>,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_buffer_collection_properties_fuchsia;
	let _: Signature = vk::Device::get_buffer_collection_properties_fuchsia;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_buffer_collection_properties_fuchsia(
				&fixture.device,
				std::mem::zeroed::<vk::BufferCollectionFUCHSIA>(),
				std::mem::zeroed::<*mut vk::BufferCollectionPropertiesFUCHSIA<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetBufferCollectionPropertiesFUCHSIA"
			))
		));
		assert!(matches!(
			fixture.device.get_buffer_collection_properties_fuchsia(
				std::mem::zeroed::<vk::BufferCollectionFUCHSIA>(),
				std::mem::zeroed::<*mut vk::BufferCollectionPropertiesFUCHSIA<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetBufferCollectionPropertiesFUCHSIA"
			))
		));
	}
}

#[cfg(feature = "platform-fuchsia")]
#[test]
fn get_buffer_collection_properties_fuchsia_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::BufferCollectionFUCHSIA,
		arg_2: *mut vk::BufferCollectionPropertiesFUCHSIA<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::BufferCollectionFUCHSIA::from_raw(305398016_u64 as _)
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *mut vk::BufferCollectionPropertiesFUCHSIA<'_>,
					)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetBufferCollectionPropertiesFUCHSIA = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetBufferCollectionPropertiesFUCHSIA,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkGetBufferCollectionPropertiesFUCHSIA", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_buffer_collection_properties_fuchsia(
					&fixture.device,
					vk::BufferCollectionFUCHSIA::from_raw(305398016_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::BufferCollectionPropertiesFUCHSIA<'_>
				),
				expected
			);
			assert_eq!(
				vk::Device::get_buffer_collection_properties_fuchsia(
					&fixture.device,
					vk::BufferCollectionFUCHSIA::from_raw(305398016_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::BufferCollectionPropertiesFUCHSIA<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[cfg(feature = "provisional")]
#[test]
fn create_cuda_module_nv_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::CudaModuleCreateInfoNV<'_>,
		*const vk::AllocationCallbacks,
		*mut vk::CudaModuleNV,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::create_cuda_module_nv;
	let _: Signature = vk::Device::create_cuda_module_nv;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::create_cuda_module_nv(
				&fixture.device,
				std::mem::zeroed::<*const vk::CudaModuleCreateInfoNV<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::CudaModuleNV>()
			),
			Err(CallError::MissingCommand("vkCreateCudaModuleNV"))
		));
		assert!(matches!(
			fixture.device.create_cuda_module_nv(
				std::mem::zeroed::<*const vk::CudaModuleCreateInfoNV<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::CudaModuleNV>()
			),
			Err(CallError::MissingCommand("vkCreateCudaModuleNV"))
		));
	}
}

#[cfg(feature = "provisional")]
#[test]
fn create_cuda_module_nv_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::CudaModuleCreateInfoNV<'_>,
		arg_2: *const vk::AllocationCallbacks,
		arg_3: *mut vk::CudaModuleNV,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::CudaModuleCreateInfoNV<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
				) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::CudaModuleNV,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCreateCudaModuleNV = Some(mock);
		let erased = std::mem::transmute::<vk::PFN_vkCreateCudaModuleNV, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCreateCudaModuleNV", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::create_cuda_module_nv(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::CudaModuleCreateInfoNV<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::CudaModuleNV
				),
				expected
			);
			assert_eq!(
				vk::Device::create_cuda_module_nv(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::CudaModuleCreateInfoNV<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::CudaModuleNV
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[cfg(feature = "provisional")]
#[test]
fn get_cuda_module_cache_nv_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CudaModuleNV,
		*mut usize,
		*mut std::ffi::c_void,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_cuda_module_cache_nv;
	let _: Signature = vk::Device::get_cuda_module_cache_nv;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_cuda_module_cache_nv(
				&fixture.device,
				std::mem::zeroed::<vk::CudaModuleNV>(),
				std::mem::zeroed::<*mut usize>(),
				std::mem::zeroed::<*mut std::ffi::c_void>()
			),
			Err(CallError::MissingCommand("vkGetCudaModuleCacheNV"))
		));
		assert!(matches!(
			fixture.device.get_cuda_module_cache_nv(
				std::mem::zeroed::<vk::CudaModuleNV>(),
				std::mem::zeroed::<*mut usize>(),
				std::mem::zeroed::<*mut std::ffi::c_void>()
			),
			Err(CallError::MissingCommand("vkGetCudaModuleCacheNV"))
		));
	}
}

#[cfg(feature = "provisional")]
#[test]
fn get_cuda_module_cache_nv_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::CudaModuleNV,
		arg_2: *mut usize,
		arg_3: *mut std::ffi::c_void,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::CudaModuleNV::from_raw(305398016_u64 as _)
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut usize,
					) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528),
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetCudaModuleCacheNV = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkGetCudaModuleCacheNV, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkGetCudaModuleCacheNV", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_cuda_module_cache_nv(
					&fixture.device,
					vk::CudaModuleNV::from_raw(305398016_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut usize,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
				),
				expected
			);
			assert_eq!(
				vk::Device::get_cuda_module_cache_nv(
					&fixture.device,
					vk::CudaModuleNV::from_raw(305398016_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut usize,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[cfg(feature = "provisional")]
#[test]
fn create_cuda_function_nv_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::CudaFunctionCreateInfoNV<'_>,
		*const vk::AllocationCallbacks,
		*mut vk::CudaFunctionNV,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::create_cuda_function_nv;
	let _: Signature = vk::Device::create_cuda_function_nv;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::create_cuda_function_nv(
				&fixture.device,
				std::mem::zeroed::<*const vk::CudaFunctionCreateInfoNV<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::CudaFunctionNV>()
			),
			Err(CallError::MissingCommand("vkCreateCudaFunctionNV"))
		));
		assert!(matches!(
			fixture.device.create_cuda_function_nv(
				std::mem::zeroed::<*const vk::CudaFunctionCreateInfoNV<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::CudaFunctionNV>()
			),
			Err(CallError::MissingCommand("vkCreateCudaFunctionNV"))
		));
	}
}

#[cfg(feature = "provisional")]
#[test]
fn create_cuda_function_nv_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::CudaFunctionCreateInfoNV<'_>,
		arg_2: *const vk::AllocationCallbacks,
		arg_3: *mut vk::CudaFunctionNV,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::CudaFunctionCreateInfoNV<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
				) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::CudaFunctionNV,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCreateCudaFunctionNV = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCreateCudaFunctionNV, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCreateCudaFunctionNV", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::create_cuda_function_nv(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::CudaFunctionCreateInfoNV<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::CudaFunctionNV
				),
				expected
			);
			assert_eq!(
				vk::Device::create_cuda_function_nv(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::CudaFunctionCreateInfoNV<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::CudaFunctionNV
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[cfg(feature = "provisional")]
#[test]
fn destroy_cuda_module_nv_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CudaModuleNV,
		*const vk::AllocationCallbacks,
	) -> Result<(), CallError>;
	let _: Signature = vk::destroy_cuda_module_nv;
	let _: Signature = vk::Device::destroy_cuda_module_nv;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::destroy_cuda_module_nv(
				&fixture.device,
				std::mem::zeroed::<vk::CudaModuleNV>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>()
			),
			Err(CallError::MissingCommand("vkDestroyCudaModuleNV"))
		));
		assert!(matches!(
			fixture.device.destroy_cuda_module_nv(
				std::mem::zeroed::<vk::CudaModuleNV>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>()
			),
			Err(CallError::MissingCommand("vkDestroyCudaModuleNV"))
		));
	}
}

#[cfg(feature = "provisional")]
#[test]
fn destroy_cuda_module_nv_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::CudaModuleNV,
		arg_2: *const vk::AllocationCallbacks,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::CudaModuleNV::from_raw(305398016_u64 as _)
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *const vk::AllocationCallbacks,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkDestroyCudaModuleNV = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkDestroyCudaModuleNV, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkDestroyCudaModuleNV", erased);
		let resolutions = Fixture::query_count();
		vk::destroy_cuda_module_nv(
			&fixture.device,
			vk::CudaModuleNV::from_raw(305398016_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::AllocationCallbacks,
		)
		.unwrap();
		vk::Device::destroy_cuda_module_nv(
			&fixture.device,
			vk::CudaModuleNV::from_raw(305398016_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::AllocationCallbacks,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[cfg(feature = "provisional")]
#[test]
fn destroy_cuda_function_nv_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CudaFunctionNV,
		*const vk::AllocationCallbacks,
	) -> Result<(), CallError>;
	let _: Signature = vk::destroy_cuda_function_nv;
	let _: Signature = vk::Device::destroy_cuda_function_nv;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::destroy_cuda_function_nv(
				&fixture.device,
				std::mem::zeroed::<vk::CudaFunctionNV>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>()
			),
			Err(CallError::MissingCommand("vkDestroyCudaFunctionNV"))
		));
		assert!(matches!(
			fixture.device.destroy_cuda_function_nv(
				std::mem::zeroed::<vk::CudaFunctionNV>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>()
			),
			Err(CallError::MissingCommand("vkDestroyCudaFunctionNV"))
		));
	}
}

#[cfg(feature = "provisional")]
#[test]
fn destroy_cuda_function_nv_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::CudaFunctionNV,
		arg_2: *const vk::AllocationCallbacks,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::CudaFunctionNV::from_raw(305398016_u64 as _)
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *const vk::AllocationCallbacks,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkDestroyCudaFunctionNV = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkDestroyCudaFunctionNV, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkDestroyCudaFunctionNV", erased);
		let resolutions = Fixture::query_count();
		vk::destroy_cuda_function_nv(
			&fixture.device,
			vk::CudaFunctionNV::from_raw(305398016_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::AllocationCallbacks,
		)
		.unwrap();
		vk::Device::destroy_cuda_function_nv(
			&fixture.device,
			vk::CudaFunctionNV::from_raw(305398016_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::AllocationCallbacks,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[cfg(feature = "provisional")]
#[test]
fn cmd_cuda_launch_kernel_nv_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		*const vk::CudaLaunchInfoNV<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_cuda_launch_kernel_nv;
	let _: Signature = vk::Device::cmd_cuda_launch_kernel_nv;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_cuda_launch_kernel_nv(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::CudaLaunchInfoNV<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdCudaLaunchKernelNV"))
		));
		assert!(matches!(
			fixture.device.cmd_cuda_launch_kernel_nv(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::CudaLaunchInfoNV<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdCudaLaunchKernelNV"))
		));
	}
}

#[cfg(feature = "provisional")]
#[test]
fn cmd_cuda_launch_kernel_nv_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::CommandBuffer, arg_1: *const vk::CudaLaunchInfoNV<'_>) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::CudaLaunchInfoNV<'_>,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdCudaLaunchKernelNV = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdCudaLaunchKernelNV, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdCudaLaunchKernelNV", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_cuda_launch_kernel_nv(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::CudaLaunchInfoNV<'_>,
		)
		.unwrap();
		vk::Device::cmd_cuda_launch_kernel_nv(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::CudaLaunchInfoNV<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_begin_rendering_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		*const vk::RenderingInfo<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_begin_rendering;
	let _: Signature = vk::Device::cmd_begin_rendering;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_begin_rendering(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::RenderingInfo<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdBeginRendering"))
		));
		assert!(matches!(
			fixture.device.cmd_begin_rendering(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::RenderingInfo<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdBeginRendering"))
		));
	}
}

#[test]
fn cmd_begin_rendering_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::CommandBuffer, arg_1: *const vk::RenderingInfo<'_>) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::RenderingInfo<'_>,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdBeginRendering = Some(mock);
		let erased = std::mem::transmute::<vk::PFN_vkCmdBeginRendering, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdBeginRendering", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_begin_rendering(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::RenderingInfo<'_>,
		)
		.unwrap();
		vk::Device::cmd_begin_rendering(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::RenderingInfo<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_begin_rendering_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		*const vk::RenderingInfo<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_begin_rendering_khr;
	let _: Signature = vk::Device::cmd_begin_rendering_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_begin_rendering_khr(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::RenderingInfo<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdBeginRenderingKHR"))
		));
		assert!(matches!(
			fixture.device.cmd_begin_rendering_khr(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::RenderingInfo<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdBeginRenderingKHR"))
		));
	}
}

#[test]
fn cmd_begin_rendering_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::CommandBuffer, arg_1: *const vk::RenderingInfo<'_>) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::RenderingInfo<'_>,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdBeginRenderingKHR = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdBeginRenderingKHR, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdBeginRenderingKHR", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_begin_rendering_khr(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::RenderingInfo<'_>,
		)
		.unwrap();
		vk::Device::cmd_begin_rendering_khr(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::RenderingInfo<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_end_rendering_signature_and_missing_command() {
	type Signature = unsafe fn(&vk::Device, vk::CommandBuffer) -> Result<(), CallError>;
	let _: Signature = vk::cmd_end_rendering;
	let _: Signature = vk::Device::cmd_end_rendering;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_end_rendering(&fixture.device, std::mem::zeroed::<vk::CommandBuffer>()),
			Err(CallError::MissingCommand("vkCmdEndRendering"))
		));
		assert!(matches!(
			fixture
				.device
				.cmd_end_rendering(std::mem::zeroed::<vk::CommandBuffer>()),
			Err(CallError::MissingCommand("vkCmdEndRendering"))
		));
	}
}

#[test]
fn cmd_end_rendering_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::CommandBuffer) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(MATCHED.get() && (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)));
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdEndRendering = Some(mock);
		let erased = std::mem::transmute::<vk::PFN_vkCmdEndRendering, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdEndRendering", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_end_rendering(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
		)
		.unwrap();
		vk::Device::cmd_end_rendering(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_end_rendering2_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		*const vk::RenderingEndInfoKHR<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_end_rendering2_khr;
	let _: Signature = vk::Device::cmd_end_rendering2_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_end_rendering2_khr(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::RenderingEndInfoKHR<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdEndRendering2KHR"))
		));
		assert!(matches!(
			fixture.device.cmd_end_rendering2_khr(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::RenderingEndInfoKHR<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdEndRendering2KHR"))
		));
	}
}

#[test]
fn cmd_end_rendering2_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: *const vk::RenderingEndInfoKHR<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::RenderingEndInfoKHR<'_>,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdEndRendering2KHR = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdEndRendering2KHR, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdEndRendering2KHR", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_end_rendering2_khr(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::RenderingEndInfoKHR<'_>,
		)
		.unwrap();
		vk::Device::cmd_end_rendering2_khr(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::RenderingEndInfoKHR<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_end_rendering2_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		*const vk::RenderingEndInfoKHR<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_end_rendering2_ext;
	let _: Signature = vk::Device::cmd_end_rendering2_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_end_rendering2_ext(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::RenderingEndInfoKHR<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdEndRendering2EXT"))
		));
		assert!(matches!(
			fixture.device.cmd_end_rendering2_ext(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::RenderingEndInfoKHR<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdEndRendering2EXT"))
		));
	}
}

#[test]
fn cmd_end_rendering2_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: *const vk::RenderingEndInfoKHR<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::RenderingEndInfoKHR<'_>,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdEndRendering2EXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdEndRendering2EXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdEndRendering2EXT", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_end_rendering2_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::RenderingEndInfoKHR<'_>,
		)
		.unwrap();
		vk::Device::cmd_end_rendering2_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::RenderingEndInfoKHR<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_end_rendering_khr_signature_and_missing_command() {
	type Signature = unsafe fn(&vk::Device, vk::CommandBuffer) -> Result<(), CallError>;
	let _: Signature = vk::cmd_end_rendering_khr;
	let _: Signature = vk::Device::cmd_end_rendering_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_end_rendering_khr(&fixture.device, std::mem::zeroed::<vk::CommandBuffer>()),
			Err(CallError::MissingCommand("vkCmdEndRenderingKHR"))
		));
		assert!(matches!(
			fixture
				.device
				.cmd_end_rendering_khr(std::mem::zeroed::<vk::CommandBuffer>()),
			Err(CallError::MissingCommand("vkCmdEndRenderingKHR"))
		));
	}
}

#[test]
fn cmd_end_rendering_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::CommandBuffer) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(MATCHED.get() && (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)));
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdEndRenderingKHR = Some(mock);
		let erased = std::mem::transmute::<vk::PFN_vkCmdEndRenderingKHR, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdEndRenderingKHR", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_end_rendering_khr(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
		)
		.unwrap();
		vk::Device::cmd_end_rendering_khr(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_descriptor_set_layout_host_mapping_info_valve_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::DescriptorSetBindingReferenceVALVE<'_>,
		*mut vk::DescriptorSetLayoutHostMappingInfoVALVE<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::get_descriptor_set_layout_host_mapping_info_valve;
	let _: Signature = vk::Device::get_descriptor_set_layout_host_mapping_info_valve;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_descriptor_set_layout_host_mapping_info_valve(
				&fixture.device,
				std::mem::zeroed::<*const vk::DescriptorSetBindingReferenceVALVE<'_>>(),
				std::mem::zeroed::<*mut vk::DescriptorSetLayoutHostMappingInfoVALVE<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetDescriptorSetLayoutHostMappingInfoVALVE"
			))
		));
		assert!(matches!(
			fixture
				.device
				.get_descriptor_set_layout_host_mapping_info_valve(
					std::mem::zeroed::<*const vk::DescriptorSetBindingReferenceVALVE<'_>>(),
					std::mem::zeroed::<*mut vk::DescriptorSetLayoutHostMappingInfoVALVE<'_>>()
				),
			Err(CallError::MissingCommand(
				"vkGetDescriptorSetLayoutHostMappingInfoVALVE"
			))
		));
	}
}

#[test]
fn get_descriptor_set_layout_host_mapping_info_valve_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::DescriptorSetBindingReferenceVALVE<'_>,
		arg_2: *mut vk::DescriptorSetLayoutHostMappingInfoVALVE<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::DescriptorSetBindingReferenceVALVE<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::DescriptorSetLayoutHostMappingInfoVALVE<'_>,
				)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture =
			Fixture::new_with_command(c"vkGetDescriptorSetLayoutHostMappingInfoVALVE", erased);
		let resolutions = Fixture::query_count();
		vk::get_descriptor_set_layout_host_mapping_info_valve(
			&fixture.device,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::DescriptorSetBindingReferenceVALVE<'_>,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *mut vk::DescriptorSetLayoutHostMappingInfoVALVE<'_>,
		)
		.unwrap();
		vk::Device::get_descriptor_set_layout_host_mapping_info_valve(
			&fixture.device,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::DescriptorSetBindingReferenceVALVE<'_>,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *mut vk::DescriptorSetLayoutHostMappingInfoVALVE<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_descriptor_set_host_mapping_valve_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, vk::DescriptorSet, *mut *mut std::ffi::c_void) -> Result<(), CallError>;
	let _: Signature = vk::get_descriptor_set_host_mapping_valve;
	let _: Signature = vk::Device::get_descriptor_set_host_mapping_valve;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_descriptor_set_host_mapping_valve(
				&fixture.device,
				std::mem::zeroed::<vk::DescriptorSet>(),
				std::mem::zeroed::<*mut *mut std::ffi::c_void>()
			),
			Err(CallError::MissingCommand(
				"vkGetDescriptorSetHostMappingVALVE"
			))
		));
		assert!(matches!(
			fixture.device.get_descriptor_set_host_mapping_valve(
				std::mem::zeroed::<vk::DescriptorSet>(),
				std::mem::zeroed::<*mut *mut std::ffi::c_void>()
			),
			Err(CallError::MissingCommand(
				"vkGetDescriptorSetHostMappingVALVE"
			))
		));
	}
}

#[test]
fn get_descriptor_set_host_mapping_valve_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::DescriptorSet,
		arg_2: *mut *mut std::ffi::c_void,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::DescriptorSet::from_raw(305398016_u64 as _)
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *mut *mut std::ffi::c_void,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetDescriptorSetHostMappingVALVE = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetDescriptorSetHostMappingVALVE,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkGetDescriptorSetHostMappingVALVE", erased);
		let resolutions = Fixture::query_count();
		vk::get_descriptor_set_host_mapping_valve(
			&fixture.device,
			vk::DescriptorSet::from_raw(305398016_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut *mut std::ffi::c_void,
		)
		.unwrap();
		vk::Device::get_descriptor_set_host_mapping_valve(
			&fixture.device,
			vk::DescriptorSet::from_raw(305398016_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut *mut std::ffi::c_void,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn create_micromap_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::MicromapCreateInfoEXT<'_>,
		*const vk::AllocationCallbacks,
		*mut vk::MicromapEXT,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::create_micromap_ext;
	let _: Signature = vk::Device::create_micromap_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::create_micromap_ext(
				&fixture.device,
				std::mem::zeroed::<*const vk::MicromapCreateInfoEXT<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::MicromapEXT>()
			),
			Err(CallError::MissingCommand("vkCreateMicromapEXT"))
		));
		assert!(matches!(
			fixture.device.create_micromap_ext(
				std::mem::zeroed::<*const vk::MicromapCreateInfoEXT<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::MicromapEXT>()
			),
			Err(CallError::MissingCommand("vkCreateMicromapEXT"))
		));
	}
}

#[test]
fn create_micromap_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::MicromapCreateInfoEXT<'_>,
		arg_2: *const vk::AllocationCallbacks,
		arg_3: *mut vk::MicromapEXT,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::MicromapCreateInfoEXT<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
				) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::MicromapEXT,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCreateMicromapEXT = Some(mock);
		let erased = std::mem::transmute::<vk::PFN_vkCreateMicromapEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCreateMicromapEXT", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::create_micromap_ext(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::MicromapCreateInfoEXT<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::MicromapEXT
				),
				expected
			);
			assert_eq!(
				vk::Device::create_micromap_ext(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::MicromapCreateInfoEXT<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::MicromapEXT
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_build_micromaps_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		u32,
		*const vk::MicromapBuildInfoEXT<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_build_micromaps_ext;
	let _: Signature = vk::Device::cmd_build_micromaps_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_build_micromaps_ext(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::MicromapBuildInfoEXT<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdBuildMicromapsEXT"))
		));
		assert!(matches!(
			fixture.device.cmd_build_micromaps_ext(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::MicromapBuildInfoEXT<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdBuildMicromapsEXT"))
		));
	}
}

#[test]
fn cmd_build_micromaps_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: u32,
		arg_2: *const vk::MicromapBuildInfoEXT<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == Default::default()
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *const vk::MicromapBuildInfoEXT<'_>,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdBuildMicromapsEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdBuildMicromapsEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdBuildMicromapsEXT", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_build_micromaps_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::MicromapBuildInfoEXT<'_>,
		)
		.unwrap();
		vk::Device::cmd_build_micromaps_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::MicromapBuildInfoEXT<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn build_micromaps_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::DeferredOperationKHR,
		u32,
		*const vk::MicromapBuildInfoEXT<'_>,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::build_micromaps_ext;
	let _: Signature = vk::Device::build_micromaps_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::build_micromaps_ext(
				&fixture.device,
				std::mem::zeroed::<vk::DeferredOperationKHR>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::MicromapBuildInfoEXT<'_>>()
			),
			Err(CallError::MissingCommand("vkBuildMicromapsEXT"))
		));
		assert!(matches!(
			fixture.device.build_micromaps_ext(
				std::mem::zeroed::<vk::DeferredOperationKHR>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::MicromapBuildInfoEXT<'_>>()
			),
			Err(CallError::MissingCommand("vkBuildMicromapsEXT"))
		));
	}
}

#[test]
fn build_micromaps_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::DeferredOperationKHR,
		arg_2: u32,
		arg_3: *const vk::MicromapBuildInfoEXT<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::DeferredOperationKHR::from_raw(305398016_u64 as _)
					&& arg_2 == Default::default()
					&& std::ptr::eq(
						arg_3,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
							as *const vk::MicromapBuildInfoEXT<'_>,
					)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkBuildMicromapsEXT = Some(mock);
		let erased = std::mem::transmute::<vk::PFN_vkBuildMicromapsEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkBuildMicromapsEXT", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::build_micromaps_ext(
					&fixture.device,
					vk::DeferredOperationKHR::from_raw(305398016_u64 as _),
					Default::default(),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *const vk::MicromapBuildInfoEXT<'_>
				),
				expected
			);
			assert_eq!(
				vk::Device::build_micromaps_ext(
					&fixture.device,
					vk::DeferredOperationKHR::from_raw(305398016_u64 as _),
					Default::default(),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *const vk::MicromapBuildInfoEXT<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn destroy_micromap_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::MicromapEXT,
		*const vk::AllocationCallbacks,
	) -> Result<(), CallError>;
	let _: Signature = vk::destroy_micromap_ext;
	let _: Signature = vk::Device::destroy_micromap_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::destroy_micromap_ext(
				&fixture.device,
				std::mem::zeroed::<vk::MicromapEXT>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>()
			),
			Err(CallError::MissingCommand("vkDestroyMicromapEXT"))
		));
		assert!(matches!(
			fixture.device.destroy_micromap_ext(
				std::mem::zeroed::<vk::MicromapEXT>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>()
			),
			Err(CallError::MissingCommand("vkDestroyMicromapEXT"))
		));
	}
}

#[test]
fn destroy_micromap_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::MicromapEXT,
		arg_2: *const vk::AllocationCallbacks,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::MicromapEXT::from_raw(305398016_u64 as _)
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *const vk::AllocationCallbacks,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkDestroyMicromapEXT = Some(mock);
		let erased = std::mem::transmute::<vk::PFN_vkDestroyMicromapEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkDestroyMicromapEXT", erased);
		let resolutions = Fixture::query_count();
		vk::destroy_micromap_ext(
			&fixture.device,
			vk::MicromapEXT::from_raw(305398016_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::AllocationCallbacks,
		)
		.unwrap();
		vk::Device::destroy_micromap_ext(
			&fixture.device,
			vk::MicromapEXT::from_raw(305398016_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::AllocationCallbacks,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_copy_micromap_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		*const vk::CopyMicromapInfoEXT<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_copy_micromap_ext;
	let _: Signature = vk::Device::cmd_copy_micromap_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_copy_micromap_ext(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::CopyMicromapInfoEXT<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdCopyMicromapEXT"))
		));
		assert!(matches!(
			fixture.device.cmd_copy_micromap_ext(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::CopyMicromapInfoEXT<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdCopyMicromapEXT"))
		));
	}
}

#[test]
fn cmd_copy_micromap_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: *const vk::CopyMicromapInfoEXT<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::CopyMicromapInfoEXT<'_>,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdCopyMicromapEXT = Some(mock);
		let erased = std::mem::transmute::<vk::PFN_vkCmdCopyMicromapEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdCopyMicromapEXT", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_copy_micromap_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::CopyMicromapInfoEXT<'_>,
		)
		.unwrap();
		vk::Device::cmd_copy_micromap_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::CopyMicromapInfoEXT<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn copy_micromap_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::DeferredOperationKHR,
		*const vk::CopyMicromapInfoEXT<'_>,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::copy_micromap_ext;
	let _: Signature = vk::Device::copy_micromap_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::copy_micromap_ext(
				&fixture.device,
				std::mem::zeroed::<vk::DeferredOperationKHR>(),
				std::mem::zeroed::<*const vk::CopyMicromapInfoEXT<'_>>()
			),
			Err(CallError::MissingCommand("vkCopyMicromapEXT"))
		));
		assert!(matches!(
			fixture.device.copy_micromap_ext(
				std::mem::zeroed::<vk::DeferredOperationKHR>(),
				std::mem::zeroed::<*const vk::CopyMicromapInfoEXT<'_>>()
			),
			Err(CallError::MissingCommand("vkCopyMicromapEXT"))
		));
	}
}

#[test]
fn copy_micromap_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::DeferredOperationKHR,
		arg_2: *const vk::CopyMicromapInfoEXT<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::DeferredOperationKHR::from_raw(305398016_u64 as _)
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *const vk::CopyMicromapInfoEXT<'_>,
					)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCopyMicromapEXT = Some(mock);
		let erased = std::mem::transmute::<vk::PFN_vkCopyMicromapEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCopyMicromapEXT", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::copy_micromap_ext(
					&fixture.device,
					vk::DeferredOperationKHR::from_raw(305398016_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::CopyMicromapInfoEXT<'_>
				),
				expected
			);
			assert_eq!(
				vk::Device::copy_micromap_ext(
					&fixture.device,
					vk::DeferredOperationKHR::from_raw(305398016_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::CopyMicromapInfoEXT<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_copy_micromap_to_memory_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		*const vk::CopyMicromapToMemoryInfoEXT<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_copy_micromap_to_memory_ext;
	let _: Signature = vk::Device::cmd_copy_micromap_to_memory_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_copy_micromap_to_memory_ext(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::CopyMicromapToMemoryInfoEXT<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdCopyMicromapToMemoryEXT"))
		));
		assert!(matches!(
			fixture.device.cmd_copy_micromap_to_memory_ext(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::CopyMicromapToMemoryInfoEXT<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdCopyMicromapToMemoryEXT"))
		));
	}
}

#[test]
fn cmd_copy_micromap_to_memory_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: *const vk::CopyMicromapToMemoryInfoEXT<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::CopyMicromapToMemoryInfoEXT<'_>,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdCopyMicromapToMemoryEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdCopyMicromapToMemoryEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdCopyMicromapToMemoryEXT", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_copy_micromap_to_memory_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::CopyMicromapToMemoryInfoEXT<'_>,
		)
		.unwrap();
		vk::Device::cmd_copy_micromap_to_memory_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::CopyMicromapToMemoryInfoEXT<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn copy_micromap_to_memory_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::DeferredOperationKHR,
		*const vk::CopyMicromapToMemoryInfoEXT<'_>,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::copy_micromap_to_memory_ext;
	let _: Signature = vk::Device::copy_micromap_to_memory_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::copy_micromap_to_memory_ext(
				&fixture.device,
				std::mem::zeroed::<vk::DeferredOperationKHR>(),
				std::mem::zeroed::<*const vk::CopyMicromapToMemoryInfoEXT<'_>>()
			),
			Err(CallError::MissingCommand("vkCopyMicromapToMemoryEXT"))
		));
		assert!(matches!(
			fixture.device.copy_micromap_to_memory_ext(
				std::mem::zeroed::<vk::DeferredOperationKHR>(),
				std::mem::zeroed::<*const vk::CopyMicromapToMemoryInfoEXT<'_>>()
			),
			Err(CallError::MissingCommand("vkCopyMicromapToMemoryEXT"))
		));
	}
}

#[test]
fn copy_micromap_to_memory_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::DeferredOperationKHR,
		arg_2: *const vk::CopyMicromapToMemoryInfoEXT<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::DeferredOperationKHR::from_raw(305398016_u64 as _)
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *const vk::CopyMicromapToMemoryInfoEXT<'_>,
					)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCopyMicromapToMemoryEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCopyMicromapToMemoryEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCopyMicromapToMemoryEXT", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::copy_micromap_to_memory_ext(
					&fixture.device,
					vk::DeferredOperationKHR::from_raw(305398016_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::CopyMicromapToMemoryInfoEXT<'_>
				),
				expected
			);
			assert_eq!(
				vk::Device::copy_micromap_to_memory_ext(
					&fixture.device,
					vk::DeferredOperationKHR::from_raw(305398016_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::CopyMicromapToMemoryInfoEXT<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_copy_memory_to_micromap_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		*const vk::CopyMemoryToMicromapInfoEXT<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_copy_memory_to_micromap_ext;
	let _: Signature = vk::Device::cmd_copy_memory_to_micromap_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_copy_memory_to_micromap_ext(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::CopyMemoryToMicromapInfoEXT<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdCopyMemoryToMicromapEXT"))
		));
		assert!(matches!(
			fixture.device.cmd_copy_memory_to_micromap_ext(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::CopyMemoryToMicromapInfoEXT<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdCopyMemoryToMicromapEXT"))
		));
	}
}

#[test]
fn cmd_copy_memory_to_micromap_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: *const vk::CopyMemoryToMicromapInfoEXT<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::CopyMemoryToMicromapInfoEXT<'_>,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdCopyMemoryToMicromapEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdCopyMemoryToMicromapEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdCopyMemoryToMicromapEXT", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_copy_memory_to_micromap_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::CopyMemoryToMicromapInfoEXT<'_>,
		)
		.unwrap();
		vk::Device::cmd_copy_memory_to_micromap_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::CopyMemoryToMicromapInfoEXT<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn copy_memory_to_micromap_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::DeferredOperationKHR,
		*const vk::CopyMemoryToMicromapInfoEXT<'_>,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::copy_memory_to_micromap_ext;
	let _: Signature = vk::Device::copy_memory_to_micromap_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::copy_memory_to_micromap_ext(
				&fixture.device,
				std::mem::zeroed::<vk::DeferredOperationKHR>(),
				std::mem::zeroed::<*const vk::CopyMemoryToMicromapInfoEXT<'_>>()
			),
			Err(CallError::MissingCommand("vkCopyMemoryToMicromapEXT"))
		));
		assert!(matches!(
			fixture.device.copy_memory_to_micromap_ext(
				std::mem::zeroed::<vk::DeferredOperationKHR>(),
				std::mem::zeroed::<*const vk::CopyMemoryToMicromapInfoEXT<'_>>()
			),
			Err(CallError::MissingCommand("vkCopyMemoryToMicromapEXT"))
		));
	}
}

#[test]
fn copy_memory_to_micromap_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::DeferredOperationKHR,
		arg_2: *const vk::CopyMemoryToMicromapInfoEXT<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::DeferredOperationKHR::from_raw(305398016_u64 as _)
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *const vk::CopyMemoryToMicromapInfoEXT<'_>,
					)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCopyMemoryToMicromapEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCopyMemoryToMicromapEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCopyMemoryToMicromapEXT", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::copy_memory_to_micromap_ext(
					&fixture.device,
					vk::DeferredOperationKHR::from_raw(305398016_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::CopyMemoryToMicromapInfoEXT<'_>
				),
				expected
			);
			assert_eq!(
				vk::Device::copy_memory_to_micromap_ext(
					&fixture.device,
					vk::DeferredOperationKHR::from_raw(305398016_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::CopyMemoryToMicromapInfoEXT<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_write_micromaps_properties_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		u32,
		*const vk::MicromapEXT,
		vk::QueryType,
		vk::QueryPool,
		u32,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_write_micromaps_properties_ext;
	let _: Signature = vk::Device::cmd_write_micromaps_properties_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_write_micromaps_properties_ext(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::MicromapEXT>(),
				std::mem::zeroed::<vk::QueryType>(),
				std::mem::zeroed::<vk::QueryPool>(),
				std::mem::zeroed::<u32>()
			),
			Err(CallError::MissingCommand(
				"vkCmdWriteMicromapsPropertiesEXT"
			))
		));
		assert!(matches!(
			fixture.device.cmd_write_micromaps_properties_ext(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::MicromapEXT>(),
				std::mem::zeroed::<vk::QueryType>(),
				std::mem::zeroed::<vk::QueryPool>(),
				std::mem::zeroed::<u32>()
			),
			Err(CallError::MissingCommand(
				"vkCmdWriteMicromapsPropertiesEXT"
			))
		));
	}
}

#[test]
fn cmd_write_micromaps_properties_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: u32,
		arg_2: *const vk::MicromapEXT,
		arg_3: vk::QueryType,
		arg_4: vk::QueryPool,
		arg_5: u32,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == Default::default()
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *const vk::MicromapEXT,
					) && arg_3 == vk::QueryType::from_raw(305398528_u64 as _)
					&& arg_4 == vk::QueryPool::from_raw(305398784_u64 as _)
					&& arg_5 == Default::default()),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdWriteMicromapsPropertiesEXT = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkCmdWriteMicromapsPropertiesEXT,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdWriteMicromapsPropertiesEXT", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_write_micromaps_properties_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *const vk::MicromapEXT,
			vk::QueryType::from_raw(305398528_u64 as _),
			vk::QueryPool::from_raw(305398784_u64 as _),
			Default::default(),
		)
		.unwrap();
		vk::Device::cmd_write_micromaps_properties_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *const vk::MicromapEXT,
			vk::QueryType::from_raw(305398528_u64 as _),
			vk::QueryPool::from_raw(305398784_u64 as _),
			Default::default(),
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn write_micromaps_properties_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		u32,
		*const vk::MicromapEXT,
		vk::QueryType,
		usize,
		*mut std::ffi::c_void,
		usize,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::write_micromaps_properties_ext;
	let _: Signature = vk::Device::write_micromaps_properties_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::write_micromaps_properties_ext(
				&fixture.device,
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::MicromapEXT>(),
				std::mem::zeroed::<vk::QueryType>(),
				std::mem::zeroed::<usize>(),
				std::mem::zeroed::<*mut std::ffi::c_void>(),
				std::mem::zeroed::<usize>()
			),
			Err(CallError::MissingCommand("vkWriteMicromapsPropertiesEXT"))
		));
		assert!(matches!(
			fixture.device.write_micromaps_properties_ext(
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::MicromapEXT>(),
				std::mem::zeroed::<vk::QueryType>(),
				std::mem::zeroed::<usize>(),
				std::mem::zeroed::<*mut std::ffi::c_void>(),
				std::mem::zeroed::<usize>()
			),
			Err(CallError::MissingCommand("vkWriteMicromapsPropertiesEXT"))
		));
	}
}

#[test]
fn write_micromaps_properties_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: u32,
		arg_2: *const vk::MicromapEXT,
		arg_3: vk::QueryType,
		arg_4: usize,
		arg_5: *mut std::ffi::c_void,
		arg_6: usize,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == Default::default()
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *const vk::MicromapEXT,
					) && arg_3 == vk::QueryType::from_raw(305398528_u64 as _)
					&& arg_4 == Default::default()
					&& std::ptr::eq(
						arg_5,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305399040),
					) && arg_6 == Default::default()),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkWriteMicromapsPropertiesEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkWriteMicromapsPropertiesEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkWriteMicromapsPropertiesEXT", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::write_micromaps_properties_ext(
					&fixture.device,
					Default::default(),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *const vk::MicromapEXT,
					vk::QueryType::from_raw(305398528_u64 as _),
					Default::default(),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305399040),
					Default::default()
				),
				expected
			);
			assert_eq!(
				vk::Device::write_micromaps_properties_ext(
					&fixture.device,
					Default::default(),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *const vk::MicromapEXT,
					vk::QueryType::from_raw(305398528_u64 as _),
					Default::default(),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305399040),
					Default::default()
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_device_micromap_compatibility_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::MicromapVersionInfoEXT<'_>,
		*mut vk::AccelerationStructureCompatibilityKHR,
	) -> Result<(), CallError>;
	let _: Signature = vk::get_device_micromap_compatibility_ext;
	let _: Signature = vk::Device::get_device_micromap_compatibility_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_device_micromap_compatibility_ext(
				&fixture.device,
				std::mem::zeroed::<*const vk::MicromapVersionInfoEXT<'_>>(),
				std::mem::zeroed::<*mut vk::AccelerationStructureCompatibilityKHR>()
			),
			Err(CallError::MissingCommand(
				"vkGetDeviceMicromapCompatibilityEXT"
			))
		));
		assert!(matches!(
			fixture.device.get_device_micromap_compatibility_ext(
				std::mem::zeroed::<*const vk::MicromapVersionInfoEXT<'_>>(),
				std::mem::zeroed::<*mut vk::AccelerationStructureCompatibilityKHR>()
			),
			Err(CallError::MissingCommand(
				"vkGetDeviceMicromapCompatibilityEXT"
			))
		));
	}
}

#[test]
fn get_device_micromap_compatibility_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::MicromapVersionInfoEXT<'_>,
		arg_2: *mut vk::AccelerationStructureCompatibilityKHR,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::MicromapVersionInfoEXT<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::AccelerationStructureCompatibilityKHR,
				)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetDeviceMicromapCompatibilityEXT = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetDeviceMicromapCompatibilityEXT,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkGetDeviceMicromapCompatibilityEXT", erased);
		let resolutions = Fixture::query_count();
		vk::get_device_micromap_compatibility_ext(
			&fixture.device,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::MicromapVersionInfoEXT<'_>,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *mut vk::AccelerationStructureCompatibilityKHR,
		)
		.unwrap();
		vk::Device::get_device_micromap_compatibility_ext(
			&fixture.device,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::MicromapVersionInfoEXT<'_>,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *mut vk::AccelerationStructureCompatibilityKHR,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_micromap_build_sizes_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::AccelerationStructureBuildTypeKHR,
		*const vk::MicromapBuildInfoEXT<'_>,
		*mut vk::MicromapBuildSizesInfoEXT<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::get_micromap_build_sizes_ext;
	let _: Signature = vk::Device::get_micromap_build_sizes_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_micromap_build_sizes_ext(
				&fixture.device,
				std::mem::zeroed::<vk::AccelerationStructureBuildTypeKHR>(),
				std::mem::zeroed::<*const vk::MicromapBuildInfoEXT<'_>>(),
				std::mem::zeroed::<*mut vk::MicromapBuildSizesInfoEXT<'_>>()
			),
			Err(CallError::MissingCommand("vkGetMicromapBuildSizesEXT"))
		));
		assert!(matches!(
			fixture.device.get_micromap_build_sizes_ext(
				std::mem::zeroed::<vk::AccelerationStructureBuildTypeKHR>(),
				std::mem::zeroed::<*const vk::MicromapBuildInfoEXT<'_>>(),
				std::mem::zeroed::<*mut vk::MicromapBuildSizesInfoEXT<'_>>()
			),
			Err(CallError::MissingCommand("vkGetMicromapBuildSizesEXT"))
		));
	}
}

#[test]
fn get_micromap_build_sizes_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::AccelerationStructureBuildTypeKHR,
		arg_2: *const vk::MicromapBuildInfoEXT<'_>,
		arg_3: *mut vk::MicromapBuildSizesInfoEXT<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::AccelerationStructureBuildTypeKHR::from_raw(305398016_u64 as _)
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *const vk::MicromapBuildInfoEXT<'_>,
					) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::MicromapBuildSizesInfoEXT<'_>,
				)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetMicromapBuildSizesEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkGetMicromapBuildSizesEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkGetMicromapBuildSizesEXT", erased);
		let resolutions = Fixture::query_count();
		vk::get_micromap_build_sizes_ext(
			&fixture.device,
			vk::AccelerationStructureBuildTypeKHR::from_raw(305398016_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::MicromapBuildInfoEXT<'_>,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
				as *mut vk::MicromapBuildSizesInfoEXT<'_>,
		)
		.unwrap();
		vk::Device::get_micromap_build_sizes_ext(
			&fixture.device,
			vk::AccelerationStructureBuildTypeKHR::from_raw(305398016_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::MicromapBuildInfoEXT<'_>,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
				as *mut vk::MicromapBuildSizesInfoEXT<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_shader_module_identifier_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::ShaderModule,
		*mut vk::ShaderModuleIdentifierEXT<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::get_shader_module_identifier_ext;
	let _: Signature = vk::Device::get_shader_module_identifier_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_shader_module_identifier_ext(
				&fixture.device,
				std::mem::zeroed::<vk::ShaderModule>(),
				std::mem::zeroed::<*mut vk::ShaderModuleIdentifierEXT<'_>>()
			),
			Err(CallError::MissingCommand("vkGetShaderModuleIdentifierEXT"))
		));
		assert!(matches!(
			fixture.device.get_shader_module_identifier_ext(
				std::mem::zeroed::<vk::ShaderModule>(),
				std::mem::zeroed::<*mut vk::ShaderModuleIdentifierEXT<'_>>()
			),
			Err(CallError::MissingCommand("vkGetShaderModuleIdentifierEXT"))
		));
	}
}

#[test]
fn get_shader_module_identifier_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::ShaderModule,
		arg_2: *mut vk::ShaderModuleIdentifierEXT<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::ShaderModule::from_raw(305398016_u64 as _)
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *mut vk::ShaderModuleIdentifierEXT<'_>,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetShaderModuleIdentifierEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkGetShaderModuleIdentifierEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkGetShaderModuleIdentifierEXT", erased);
		let resolutions = Fixture::query_count();
		vk::get_shader_module_identifier_ext(
			&fixture.device,
			vk::ShaderModule::from_raw(305398016_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *mut vk::ShaderModuleIdentifierEXT<'_>,
		)
		.unwrap();
		vk::Device::get_shader_module_identifier_ext(
			&fixture.device,
			vk::ShaderModule::from_raw(305398016_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *mut vk::ShaderModuleIdentifierEXT<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_shader_module_create_info_identifier_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::ShaderModuleCreateInfo<'_>,
		*mut vk::ShaderModuleIdentifierEXT<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::get_shader_module_create_info_identifier_ext;
	let _: Signature = vk::Device::get_shader_module_create_info_identifier_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_shader_module_create_info_identifier_ext(
				&fixture.device,
				std::mem::zeroed::<*const vk::ShaderModuleCreateInfo<'_>>(),
				std::mem::zeroed::<*mut vk::ShaderModuleIdentifierEXT<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetShaderModuleCreateInfoIdentifierEXT"
			))
		));
		assert!(matches!(
			fixture.device.get_shader_module_create_info_identifier_ext(
				std::mem::zeroed::<*const vk::ShaderModuleCreateInfo<'_>>(),
				std::mem::zeroed::<*mut vk::ShaderModuleIdentifierEXT<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetShaderModuleCreateInfoIdentifierEXT"
			))
		));
	}
}

#[test]
fn get_shader_module_create_info_identifier_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::ShaderModuleCreateInfo<'_>,
		arg_2: *mut vk::ShaderModuleIdentifierEXT<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::ShaderModuleCreateInfo<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::ShaderModuleIdentifierEXT<'_>,
				)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetShaderModuleCreateInfoIdentifierEXT = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetShaderModuleCreateInfoIdentifierEXT,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkGetShaderModuleCreateInfoIdentifierEXT", erased);
		let resolutions = Fixture::query_count();
		vk::get_shader_module_create_info_identifier_ext(
			&fixture.device,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::ShaderModuleCreateInfo<'_>,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *mut vk::ShaderModuleIdentifierEXT<'_>,
		)
		.unwrap();
		vk::Device::get_shader_module_create_info_identifier_ext(
			&fixture.device,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::ShaderModuleCreateInfo<'_>,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *mut vk::ShaderModuleIdentifierEXT<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_image_subresource_layout2_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::Image,
		*const vk::ImageSubresource2<'_>,
		*mut vk::SubresourceLayout2<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::get_image_subresource_layout2;
	let _: Signature = vk::Device::get_image_subresource_layout2;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_image_subresource_layout2(
				&fixture.device,
				std::mem::zeroed::<vk::Image>(),
				std::mem::zeroed::<*const vk::ImageSubresource2<'_>>(),
				std::mem::zeroed::<*mut vk::SubresourceLayout2<'_>>()
			),
			Err(CallError::MissingCommand("vkGetImageSubresourceLayout2"))
		));
		assert!(matches!(
			fixture.device.get_image_subresource_layout2(
				std::mem::zeroed::<vk::Image>(),
				std::mem::zeroed::<*const vk::ImageSubresource2<'_>>(),
				std::mem::zeroed::<*mut vk::SubresourceLayout2<'_>>()
			),
			Err(CallError::MissingCommand("vkGetImageSubresourceLayout2"))
		));
	}
}

#[test]
fn get_image_subresource_layout2_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::Image,
		arg_2: *const vk::ImageSubresource2<'_>,
		arg_3: *mut vk::SubresourceLayout2<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::Image::from_raw(305398016_u64 as _)
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *const vk::ImageSubresource2<'_>,
					) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::SubresourceLayout2<'_>,
				)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetImageSubresourceLayout2 = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkGetImageSubresourceLayout2, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkGetImageSubresourceLayout2", erased);
		let resolutions = Fixture::query_count();
		vk::get_image_subresource_layout2(
			&fixture.device,
			vk::Image::from_raw(305398016_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::ImageSubresource2<'_>,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
				as *mut vk::SubresourceLayout2<'_>,
		)
		.unwrap();
		vk::Device::get_image_subresource_layout2(
			&fixture.device,
			vk::Image::from_raw(305398016_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::ImageSubresource2<'_>,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
				as *mut vk::SubresourceLayout2<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_image_subresource_layout2_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::Image,
		*const vk::ImageSubresource2<'_>,
		*mut vk::SubresourceLayout2<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::get_image_subresource_layout2_khr;
	let _: Signature = vk::Device::get_image_subresource_layout2_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_image_subresource_layout2_khr(
				&fixture.device,
				std::mem::zeroed::<vk::Image>(),
				std::mem::zeroed::<*const vk::ImageSubresource2<'_>>(),
				std::mem::zeroed::<*mut vk::SubresourceLayout2<'_>>()
			),
			Err(CallError::MissingCommand("vkGetImageSubresourceLayout2KHR"))
		));
		assert!(matches!(
			fixture.device.get_image_subresource_layout2_khr(
				std::mem::zeroed::<vk::Image>(),
				std::mem::zeroed::<*const vk::ImageSubresource2<'_>>(),
				std::mem::zeroed::<*mut vk::SubresourceLayout2<'_>>()
			),
			Err(CallError::MissingCommand("vkGetImageSubresourceLayout2KHR"))
		));
	}
}

#[test]
fn get_image_subresource_layout2_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::Image,
		arg_2: *const vk::ImageSubresource2<'_>,
		arg_3: *mut vk::SubresourceLayout2<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::Image::from_raw(305398016_u64 as _)
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *const vk::ImageSubresource2<'_>,
					) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::SubresourceLayout2<'_>,
				)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetImageSubresourceLayout2KHR = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkGetImageSubresourceLayout2KHR, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkGetImageSubresourceLayout2KHR", erased);
		let resolutions = Fixture::query_count();
		vk::get_image_subresource_layout2_khr(
			&fixture.device,
			vk::Image::from_raw(305398016_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::ImageSubresource2<'_>,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
				as *mut vk::SubresourceLayout2<'_>,
		)
		.unwrap();
		vk::Device::get_image_subresource_layout2_khr(
			&fixture.device,
			vk::Image::from_raw(305398016_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::ImageSubresource2<'_>,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
				as *mut vk::SubresourceLayout2<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_image_subresource_layout2_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::Image,
		*const vk::ImageSubresource2<'_>,
		*mut vk::SubresourceLayout2<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::get_image_subresource_layout2_ext;
	let _: Signature = vk::Device::get_image_subresource_layout2_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_image_subresource_layout2_ext(
				&fixture.device,
				std::mem::zeroed::<vk::Image>(),
				std::mem::zeroed::<*const vk::ImageSubresource2<'_>>(),
				std::mem::zeroed::<*mut vk::SubresourceLayout2<'_>>()
			),
			Err(CallError::MissingCommand("vkGetImageSubresourceLayout2EXT"))
		));
		assert!(matches!(
			fixture.device.get_image_subresource_layout2_ext(
				std::mem::zeroed::<vk::Image>(),
				std::mem::zeroed::<*const vk::ImageSubresource2<'_>>(),
				std::mem::zeroed::<*mut vk::SubresourceLayout2<'_>>()
			),
			Err(CallError::MissingCommand("vkGetImageSubresourceLayout2EXT"))
		));
	}
}

#[test]
fn get_image_subresource_layout2_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::Image,
		arg_2: *const vk::ImageSubresource2<'_>,
		arg_3: *mut vk::SubresourceLayout2<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::Image::from_raw(305398016_u64 as _)
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *const vk::ImageSubresource2<'_>,
					) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::SubresourceLayout2<'_>,
				)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetImageSubresourceLayout2EXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkGetImageSubresourceLayout2EXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkGetImageSubresourceLayout2EXT", erased);
		let resolutions = Fixture::query_count();
		vk::get_image_subresource_layout2_ext(
			&fixture.device,
			vk::Image::from_raw(305398016_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::ImageSubresource2<'_>,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
				as *mut vk::SubresourceLayout2<'_>,
		)
		.unwrap();
		vk::Device::get_image_subresource_layout2_ext(
			&fixture.device,
			vk::Image::from_raw(305398016_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::ImageSubresource2<'_>,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
				as *mut vk::SubresourceLayout2<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_pipeline_properties_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::PipelineInfoKHR<'_>,
		*mut vk::BaseOutStructure<'_>,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_pipeline_properties_ext;
	let _: Signature = vk::Device::get_pipeline_properties_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_pipeline_properties_ext(
				&fixture.device,
				std::mem::zeroed::<*const vk::PipelineInfoKHR<'_>>(),
				std::mem::zeroed::<*mut vk::BaseOutStructure<'_>>()
			),
			Err(CallError::MissingCommand("vkGetPipelinePropertiesEXT"))
		));
		assert!(matches!(
			fixture.device.get_pipeline_properties_ext(
				std::mem::zeroed::<*const vk::PipelineInfoKHR<'_>>(),
				std::mem::zeroed::<*mut vk::BaseOutStructure<'_>>()
			),
			Err(CallError::MissingCommand("vkGetPipelinePropertiesEXT"))
		));
	}
}

#[test]
fn get_pipeline_properties_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::PipelineInfoKHR<'_>,
		arg_2: *mut vk::BaseOutStructure<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::PipelineInfoKHR<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::BaseOutStructure<'_>,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetPipelinePropertiesEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkGetPipelinePropertiesEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkGetPipelinePropertiesEXT", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_pipeline_properties_ext(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::PipelineInfoKHR<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::BaseOutStructure<'_>
				),
				expected
			);
			assert_eq!(
				vk::Device::get_pipeline_properties_ext(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::PipelineInfoKHR<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::BaseOutStructure<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[cfg(feature = "platform-metal")]
#[test]
fn export_metal_objects_ext_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, *mut vk::ExportMetalObjectsInfoEXT<'_>) -> Result<(), CallError>;
	let _: Signature = vk::export_metal_objects_ext;
	let _: Signature = vk::Device::export_metal_objects_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::export_metal_objects_ext(
				&fixture.device,
				std::mem::zeroed::<*mut vk::ExportMetalObjectsInfoEXT<'_>>()
			),
			Err(CallError::MissingCommand("vkExportMetalObjectsEXT"))
		));
		assert!(matches!(
			fixture
				.device
				.export_metal_objects_ext(std::mem::zeroed::<*mut vk::ExportMetalObjectsInfoEXT<'_>>()),
			Err(CallError::MissingCommand("vkExportMetalObjectsEXT"))
		));
	}
}

#[cfg(feature = "platform-metal")]
#[test]
fn export_metal_objects_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *mut vk::ExportMetalObjectsInfoEXT<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *mut vk::ExportMetalObjectsInfoEXT<'_>,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkExportMetalObjectsEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkExportMetalObjectsEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkExportMetalObjectsEXT", erased);
		let resolutions = Fixture::query_count();
		vk::export_metal_objects_ext(
			&fixture.device,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *mut vk::ExportMetalObjectsInfoEXT<'_>,
		)
		.unwrap();
		vk::Device::export_metal_objects_ext(
			&fixture.device,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *mut vk::ExportMetalObjectsInfoEXT<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_bind_tile_memory_qcom_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		*const vk::TileMemoryBindInfoQCOM<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_bind_tile_memory_qcom;
	let _: Signature = vk::Device::cmd_bind_tile_memory_qcom;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_bind_tile_memory_qcom(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::TileMemoryBindInfoQCOM<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdBindTileMemoryQCOM"))
		));
		assert!(matches!(
			fixture.device.cmd_bind_tile_memory_qcom(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::TileMemoryBindInfoQCOM<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdBindTileMemoryQCOM"))
		));
	}
}

#[test]
fn cmd_bind_tile_memory_qcom_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: *const vk::TileMemoryBindInfoQCOM<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::TileMemoryBindInfoQCOM<'_>,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdBindTileMemoryQCOM = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdBindTileMemoryQCOM, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdBindTileMemoryQCOM", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_bind_tile_memory_qcom(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::TileMemoryBindInfoQCOM<'_>,
		)
		.unwrap();
		vk::Device::cmd_bind_tile_memory_qcom(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::TileMemoryBindInfoQCOM<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_framebuffer_tile_properties_qcom_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::Framebuffer,
		*mut u32,
		*mut vk::TilePropertiesQCOM<'_>,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_framebuffer_tile_properties_qcom;
	let _: Signature = vk::Device::get_framebuffer_tile_properties_qcom;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_framebuffer_tile_properties_qcom(
				&fixture.device,
				std::mem::zeroed::<vk::Framebuffer>(),
				std::mem::zeroed::<*mut u32>(),
				std::mem::zeroed::<*mut vk::TilePropertiesQCOM<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetFramebufferTilePropertiesQCOM"
			))
		));
		assert!(matches!(
			fixture.device.get_framebuffer_tile_properties_qcom(
				std::mem::zeroed::<vk::Framebuffer>(),
				std::mem::zeroed::<*mut u32>(),
				std::mem::zeroed::<*mut vk::TilePropertiesQCOM<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetFramebufferTilePropertiesQCOM"
			))
		));
	}
}

#[test]
fn get_framebuffer_tile_properties_qcom_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::Framebuffer,
		arg_2: *mut u32,
		arg_3: *mut vk::TilePropertiesQCOM<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::Framebuffer::from_raw(305398016_u64 as _)
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut u32,
					) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::TilePropertiesQCOM<'_>,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetFramebufferTilePropertiesQCOM = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetFramebufferTilePropertiesQCOM,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkGetFramebufferTilePropertiesQCOM", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_framebuffer_tile_properties_qcom(
					&fixture.device,
					vk::Framebuffer::from_raw(305398016_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut u32,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::TilePropertiesQCOM<'_>
				),
				expected
			);
			assert_eq!(
				vk::Device::get_framebuffer_tile_properties_qcom(
					&fixture.device,
					vk::Framebuffer::from_raw(305398016_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut u32,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::TilePropertiesQCOM<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_dynamic_rendering_tile_properties_qcom_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::RenderingInfo<'_>,
		*mut vk::TilePropertiesQCOM<'_>,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_dynamic_rendering_tile_properties_qcom;
	let _: Signature = vk::Device::get_dynamic_rendering_tile_properties_qcom;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_dynamic_rendering_tile_properties_qcom(
				&fixture.device,
				std::mem::zeroed::<*const vk::RenderingInfo<'_>>(),
				std::mem::zeroed::<*mut vk::TilePropertiesQCOM<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetDynamicRenderingTilePropertiesQCOM"
			))
		));
		assert!(matches!(
			fixture.device.get_dynamic_rendering_tile_properties_qcom(
				std::mem::zeroed::<*const vk::RenderingInfo<'_>>(),
				std::mem::zeroed::<*mut vk::TilePropertiesQCOM<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetDynamicRenderingTilePropertiesQCOM"
			))
		));
	}
}

#[test]
fn get_dynamic_rendering_tile_properties_qcom_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::RenderingInfo<'_>,
		arg_2: *mut vk::TilePropertiesQCOM<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::RenderingInfo<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::TilePropertiesQCOM<'_>,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetDynamicRenderingTilePropertiesQCOM = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetDynamicRenderingTilePropertiesQCOM,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkGetDynamicRenderingTilePropertiesQCOM", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_dynamic_rendering_tile_properties_qcom(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::RenderingInfo<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::TilePropertiesQCOM<'_>
				),
				expected
			);
			assert_eq!(
				vk::Device::get_dynamic_rendering_tile_properties_qcom(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::RenderingInfo<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::TilePropertiesQCOM<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_physical_device_optical_flow_image_formats_nv_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		vk::PhysicalDevice,
		*const vk::OpticalFlowImageFormatInfoNV<'_>,
		*mut u32,
		*mut vk::OpticalFlowImageFormatPropertiesNV<'_>,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_physical_device_optical_flow_image_formats_nv;
	let _: Signature = vk::Instance::get_physical_device_optical_flow_image_formats_nv;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_physical_device_optical_flow_image_formats_nv(
				&fixture.instance,
				std::mem::zeroed::<vk::PhysicalDevice>(),
				std::mem::zeroed::<*const vk::OpticalFlowImageFormatInfoNV<'_>>(),
				std::mem::zeroed::<*mut u32>(),
				std::mem::zeroed::<*mut vk::OpticalFlowImageFormatPropertiesNV<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceOpticalFlowImageFormatsNV"
			))
		));
		assert!(matches!(
			fixture
				.instance
				.get_physical_device_optical_flow_image_formats_nv(
					std::mem::zeroed::<vk::PhysicalDevice>(),
					std::mem::zeroed::<*const vk::OpticalFlowImageFormatInfoNV<'_>>(),
					std::mem::zeroed::<*mut u32>(),
					std::mem::zeroed::<*mut vk::OpticalFlowImageFormatPropertiesNV<'_>>()
				),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceOpticalFlowImageFormatsNV"
			))
		));
	}
}

#[test]
fn get_physical_device_optical_flow_image_formats_nv_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::PhysicalDevice,
		arg_1: *const vk::OpticalFlowImageFormatInfoNV<'_>,
		arg_2: *mut u32,
		arg_3: *mut vk::OpticalFlowImageFormatPropertiesNV<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::PhysicalDevice::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::OpticalFlowImageFormatInfoNV<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut u32,
				) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::OpticalFlowImageFormatPropertiesNV<'_>,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture =
			Fixture::new_with_command(c"vkGetPhysicalDeviceOpticalFlowImageFormatsNV", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_physical_device_optical_flow_image_formats_nv(
					&fixture.instance,
					vk::PhysicalDevice::from_raw(305397760_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::OpticalFlowImageFormatInfoNV<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut u32,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::OpticalFlowImageFormatPropertiesNV<'_>
				),
				expected
			);
			assert_eq!(
				vk::Instance::get_physical_device_optical_flow_image_formats_nv(
					&fixture.instance,
					vk::PhysicalDevice::from_raw(305397760_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::OpticalFlowImageFormatInfoNV<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut u32,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::OpticalFlowImageFormatPropertiesNV<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn create_optical_flow_session_nv_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::OpticalFlowSessionCreateInfoNV<'_>,
		*const vk::AllocationCallbacks,
		*mut vk::OpticalFlowSessionNV,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::create_optical_flow_session_nv;
	let _: Signature = vk::Device::create_optical_flow_session_nv;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::create_optical_flow_session_nv(
				&fixture.device,
				std::mem::zeroed::<*const vk::OpticalFlowSessionCreateInfoNV<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::OpticalFlowSessionNV>()
			),
			Err(CallError::MissingCommand("vkCreateOpticalFlowSessionNV"))
		));
		assert!(matches!(
			fixture.device.create_optical_flow_session_nv(
				std::mem::zeroed::<*const vk::OpticalFlowSessionCreateInfoNV<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::OpticalFlowSessionNV>()
			),
			Err(CallError::MissingCommand("vkCreateOpticalFlowSessionNV"))
		));
	}
}

#[test]
fn create_optical_flow_session_nv_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::OpticalFlowSessionCreateInfoNV<'_>,
		arg_2: *const vk::AllocationCallbacks,
		arg_3: *mut vk::OpticalFlowSessionNV,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::OpticalFlowSessionCreateInfoNV<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
				) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::OpticalFlowSessionNV,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCreateOpticalFlowSessionNV = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCreateOpticalFlowSessionNV, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCreateOpticalFlowSessionNV", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::create_optical_flow_session_nv(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::OpticalFlowSessionCreateInfoNV<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::OpticalFlowSessionNV
				),
				expected
			);
			assert_eq!(
				vk::Device::create_optical_flow_session_nv(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::OpticalFlowSessionCreateInfoNV<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::OpticalFlowSessionNV
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn destroy_optical_flow_session_nv_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::OpticalFlowSessionNV,
		*const vk::AllocationCallbacks,
	) -> Result<(), CallError>;
	let _: Signature = vk::destroy_optical_flow_session_nv;
	let _: Signature = vk::Device::destroy_optical_flow_session_nv;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::destroy_optical_flow_session_nv(
				&fixture.device,
				std::mem::zeroed::<vk::OpticalFlowSessionNV>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>()
			),
			Err(CallError::MissingCommand("vkDestroyOpticalFlowSessionNV"))
		));
		assert!(matches!(
			fixture.device.destroy_optical_flow_session_nv(
				std::mem::zeroed::<vk::OpticalFlowSessionNV>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>()
			),
			Err(CallError::MissingCommand("vkDestroyOpticalFlowSessionNV"))
		));
	}
}

#[test]
fn destroy_optical_flow_session_nv_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::OpticalFlowSessionNV,
		arg_2: *const vk::AllocationCallbacks,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::OpticalFlowSessionNV::from_raw(305398016_u64 as _)
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *const vk::AllocationCallbacks,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkDestroyOpticalFlowSessionNV = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkDestroyOpticalFlowSessionNV, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkDestroyOpticalFlowSessionNV", erased);
		let resolutions = Fixture::query_count();
		vk::destroy_optical_flow_session_nv(
			&fixture.device,
			vk::OpticalFlowSessionNV::from_raw(305398016_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::AllocationCallbacks,
		)
		.unwrap();
		vk::Device::destroy_optical_flow_session_nv(
			&fixture.device,
			vk::OpticalFlowSessionNV::from_raw(305398016_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::AllocationCallbacks,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn bind_optical_flow_session_image_nv_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::OpticalFlowSessionNV,
		vk::OpticalFlowSessionBindingPointNV,
		vk::ImageView,
		vk::ImageLayout,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::bind_optical_flow_session_image_nv;
	let _: Signature = vk::Device::bind_optical_flow_session_image_nv;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::bind_optical_flow_session_image_nv(
				&fixture.device,
				std::mem::zeroed::<vk::OpticalFlowSessionNV>(),
				std::mem::zeroed::<vk::OpticalFlowSessionBindingPointNV>(),
				std::mem::zeroed::<vk::ImageView>(),
				std::mem::zeroed::<vk::ImageLayout>()
			),
			Err(CallError::MissingCommand("vkBindOpticalFlowSessionImageNV"))
		));
		assert!(matches!(
			fixture.device.bind_optical_flow_session_image_nv(
				std::mem::zeroed::<vk::OpticalFlowSessionNV>(),
				std::mem::zeroed::<vk::OpticalFlowSessionBindingPointNV>(),
				std::mem::zeroed::<vk::ImageView>(),
				std::mem::zeroed::<vk::ImageLayout>()
			),
			Err(CallError::MissingCommand("vkBindOpticalFlowSessionImageNV"))
		));
	}
}

#[test]
fn bind_optical_flow_session_image_nv_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::OpticalFlowSessionNV,
		arg_2: vk::OpticalFlowSessionBindingPointNV,
		arg_3: vk::ImageView,
		arg_4: vk::ImageLayout,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::OpticalFlowSessionNV::from_raw(305398016_u64 as _)
					&& arg_2 == vk::OpticalFlowSessionBindingPointNV::from_raw(305398272_u64 as _)
					&& arg_3 == vk::ImageView::from_raw(305398528_u64 as _)
					&& arg_4 == vk::ImageLayout::from_raw(305398784_u64 as _)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkBindOpticalFlowSessionImageNV = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkBindOpticalFlowSessionImageNV, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkBindOpticalFlowSessionImageNV", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::bind_optical_flow_session_image_nv(
					&fixture.device,
					vk::OpticalFlowSessionNV::from_raw(305398016_u64 as _),
					vk::OpticalFlowSessionBindingPointNV::from_raw(305398272_u64 as _),
					vk::ImageView::from_raw(305398528_u64 as _),
					vk::ImageLayout::from_raw(305398784_u64 as _)
				),
				expected
			);
			assert_eq!(
				vk::Device::bind_optical_flow_session_image_nv(
					&fixture.device,
					vk::OpticalFlowSessionNV::from_raw(305398016_u64 as _),
					vk::OpticalFlowSessionBindingPointNV::from_raw(305398272_u64 as _),
					vk::ImageView::from_raw(305398528_u64 as _),
					vk::ImageLayout::from_raw(305398784_u64 as _)
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_optical_flow_execute_nv_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		vk::OpticalFlowSessionNV,
		*const vk::OpticalFlowExecuteInfoNV<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_optical_flow_execute_nv;
	let _: Signature = vk::Device::cmd_optical_flow_execute_nv;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_optical_flow_execute_nv(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::OpticalFlowSessionNV>(),
				std::mem::zeroed::<*const vk::OpticalFlowExecuteInfoNV<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdOpticalFlowExecuteNV"))
		));
		assert!(matches!(
			fixture.device.cmd_optical_flow_execute_nv(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::OpticalFlowSessionNV>(),
				std::mem::zeroed::<*const vk::OpticalFlowExecuteInfoNV<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdOpticalFlowExecuteNV"))
		));
	}
}

#[test]
fn cmd_optical_flow_execute_nv_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: vk::OpticalFlowSessionNV,
		arg_2: *const vk::OpticalFlowExecuteInfoNV<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == vk::OpticalFlowSessionNV::from_raw(305398016_u64 as _)
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *const vk::OpticalFlowExecuteInfoNV<'_>,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdOpticalFlowExecuteNV = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdOpticalFlowExecuteNV, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdOpticalFlowExecuteNV", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_optical_flow_execute_nv(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::OpticalFlowSessionNV::from_raw(305398016_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::OpticalFlowExecuteInfoNV<'_>,
		)
		.unwrap();
		vk::Device::cmd_optical_flow_execute_nv(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::OpticalFlowSessionNV::from_raw(305398016_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::OpticalFlowExecuteInfoNV<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_device_fault_info_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*mut vk::DeviceFaultCountsEXT<'_>,
		*mut vk::DeviceFaultInfoEXT<'_>,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_device_fault_info_ext;
	let _: Signature = vk::Device::get_device_fault_info_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_device_fault_info_ext(
				&fixture.device,
				std::mem::zeroed::<*mut vk::DeviceFaultCountsEXT<'_>>(),
				std::mem::zeroed::<*mut vk::DeviceFaultInfoEXT<'_>>()
			),
			Err(CallError::MissingCommand("vkGetDeviceFaultInfoEXT"))
		));
		assert!(matches!(
			fixture.device.get_device_fault_info_ext(
				std::mem::zeroed::<*mut vk::DeviceFaultCountsEXT<'_>>(),
				std::mem::zeroed::<*mut vk::DeviceFaultInfoEXT<'_>>()
			),
			Err(CallError::MissingCommand("vkGetDeviceFaultInfoEXT"))
		));
	}
}

#[test]
fn get_device_fault_info_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *mut vk::DeviceFaultCountsEXT<'_>,
		arg_2: *mut vk::DeviceFaultInfoEXT<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *mut vk::DeviceFaultCountsEXT<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::DeviceFaultInfoEXT<'_>,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetDeviceFaultInfoEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkGetDeviceFaultInfoEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkGetDeviceFaultInfoEXT", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_device_fault_info_ext(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *mut vk::DeviceFaultCountsEXT<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::DeviceFaultInfoEXT<'_>
				),
				expected
			);
			assert_eq!(
				vk::Device::get_device_fault_info_ext(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *mut vk::DeviceFaultCountsEXT<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::DeviceFaultInfoEXT<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_device_fault_reports_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		u64,
		*mut u32,
		*mut vk::DeviceFaultInfoKHR<'_>,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_device_fault_reports_khr;
	let _: Signature = vk::Device::get_device_fault_reports_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_device_fault_reports_khr(
				&fixture.device,
				std::mem::zeroed::<u64>(),
				std::mem::zeroed::<*mut u32>(),
				std::mem::zeroed::<*mut vk::DeviceFaultInfoKHR<'_>>()
			),
			Err(CallError::MissingCommand("vkGetDeviceFaultReportsKHR"))
		));
		assert!(matches!(
			fixture.device.get_device_fault_reports_khr(
				std::mem::zeroed::<u64>(),
				std::mem::zeroed::<*mut u32>(),
				std::mem::zeroed::<*mut vk::DeviceFaultInfoKHR<'_>>()
			),
			Err(CallError::MissingCommand("vkGetDeviceFaultReportsKHR"))
		));
	}
}

#[test]
fn get_device_fault_reports_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: u64,
		arg_2: *mut u32,
		arg_3: *mut vk::DeviceFaultInfoKHR<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == Default::default()
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut u32,
					) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::DeviceFaultInfoKHR<'_>,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetDeviceFaultReportsKHR = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkGetDeviceFaultReportsKHR, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkGetDeviceFaultReportsKHR", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_device_fault_reports_khr(
					&fixture.device,
					Default::default(),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut u32,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::DeviceFaultInfoKHR<'_>
				),
				expected
			);
			assert_eq!(
				vk::Device::get_device_fault_reports_khr(
					&fixture.device,
					Default::default(),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut u32,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::DeviceFaultInfoKHR<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_device_fault_debug_info_khr_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, *mut vk::DeviceFaultDebugInfoKHR<'_>) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_device_fault_debug_info_khr;
	let _: Signature = vk::Device::get_device_fault_debug_info_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_device_fault_debug_info_khr(
				&fixture.device,
				std::mem::zeroed::<*mut vk::DeviceFaultDebugInfoKHR<'_>>()
			),
			Err(CallError::MissingCommand("vkGetDeviceFaultDebugInfoKHR"))
		));
		assert!(matches!(
			fixture
				.device
				.get_device_fault_debug_info_khr(std::mem::zeroed::<*mut vk::DeviceFaultDebugInfoKHR<'_>>()),
			Err(CallError::MissingCommand("vkGetDeviceFaultDebugInfoKHR"))
		));
	}
}

#[test]
fn get_device_fault_debug_info_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *mut vk::DeviceFaultDebugInfoKHR<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *mut vk::DeviceFaultDebugInfoKHR<'_>,
					)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetDeviceFaultDebugInfoKHR = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkGetDeviceFaultDebugInfoKHR, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkGetDeviceFaultDebugInfoKHR", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_device_fault_debug_info_khr(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *mut vk::DeviceFaultDebugInfoKHR<'_>
				),
				expected
			);
			assert_eq!(
				vk::Device::get_device_fault_debug_info_khr(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *mut vk::DeviceFaultDebugInfoKHR<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_set_depth_bias2_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		*const vk::DepthBiasInfoEXT<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_depth_bias2_ext;
	let _: Signature = vk::Device::cmd_set_depth_bias2_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_depth_bias2_ext(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::DepthBiasInfoEXT<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdSetDepthBias2EXT"))
		));
		assert!(matches!(
			fixture.device.cmd_set_depth_bias2_ext(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::DepthBiasInfoEXT<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdSetDepthBias2EXT"))
		));
	}
}

#[test]
fn cmd_set_depth_bias2_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::CommandBuffer, arg_1: *const vk::DepthBiasInfoEXT<'_>) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::DepthBiasInfoEXT<'_>,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdSetDepthBias2EXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdSetDepthBias2EXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdSetDepthBias2EXT", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_set_depth_bias2_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::DepthBiasInfoEXT<'_>,
		)
		.unwrap();
		vk::Device::cmd_set_depth_bias2_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::DepthBiasInfoEXT<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn release_swapchain_images_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::ReleaseSwapchainImagesInfoKHR<'_>,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::release_swapchain_images_khr;
	let _: Signature = vk::Device::release_swapchain_images_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::release_swapchain_images_khr(
				&fixture.device,
				std::mem::zeroed::<*const vk::ReleaseSwapchainImagesInfoKHR<'_>>()
			),
			Err(CallError::MissingCommand("vkReleaseSwapchainImagesKHR"))
		));
		assert!(matches!(
			fixture
				.device
				.release_swapchain_images_khr(std::mem::zeroed::<
					*const vk::ReleaseSwapchainImagesInfoKHR<'_>,
				>()),
			Err(CallError::MissingCommand("vkReleaseSwapchainImagesKHR"))
		));
	}
}

#[test]
fn release_swapchain_images_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::ReleaseSwapchainImagesInfoKHR<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::ReleaseSwapchainImagesInfoKHR<'_>,
					)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkReleaseSwapchainImagesKHR = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkReleaseSwapchainImagesKHR, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkReleaseSwapchainImagesKHR", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::release_swapchain_images_khr(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::ReleaseSwapchainImagesInfoKHR<'_>
				),
				expected
			);
			assert_eq!(
				vk::Device::release_swapchain_images_khr(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::ReleaseSwapchainImagesInfoKHR<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn release_swapchain_images_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::ReleaseSwapchainImagesInfoKHR<'_>,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::release_swapchain_images_ext;
	let _: Signature = vk::Device::release_swapchain_images_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::release_swapchain_images_ext(
				&fixture.device,
				std::mem::zeroed::<*const vk::ReleaseSwapchainImagesInfoKHR<'_>>()
			),
			Err(CallError::MissingCommand("vkReleaseSwapchainImagesEXT"))
		));
		assert!(matches!(
			fixture
				.device
				.release_swapchain_images_ext(std::mem::zeroed::<
					*const vk::ReleaseSwapchainImagesInfoKHR<'_>,
				>()),
			Err(CallError::MissingCommand("vkReleaseSwapchainImagesEXT"))
		));
	}
}

#[test]
fn release_swapchain_images_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::ReleaseSwapchainImagesInfoKHR<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::ReleaseSwapchainImagesInfoKHR<'_>,
					)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkReleaseSwapchainImagesEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkReleaseSwapchainImagesEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkReleaseSwapchainImagesEXT", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::release_swapchain_images_ext(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::ReleaseSwapchainImagesInfoKHR<'_>
				),
				expected
			);
			assert_eq!(
				vk::Device::release_swapchain_images_ext(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::ReleaseSwapchainImagesInfoKHR<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_device_image_subresource_layout_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::DeviceImageSubresourceInfo<'_>,
		*mut vk::SubresourceLayout2<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::get_device_image_subresource_layout;
	let _: Signature = vk::Device::get_device_image_subresource_layout;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_device_image_subresource_layout(
				&fixture.device,
				std::mem::zeroed::<*const vk::DeviceImageSubresourceInfo<'_>>(),
				std::mem::zeroed::<*mut vk::SubresourceLayout2<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetDeviceImageSubresourceLayout"
			))
		));
		assert!(matches!(
			fixture.device.get_device_image_subresource_layout(
				std::mem::zeroed::<*const vk::DeviceImageSubresourceInfo<'_>>(),
				std::mem::zeroed::<*mut vk::SubresourceLayout2<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetDeviceImageSubresourceLayout"
			))
		));
	}
}

#[test]
fn get_device_image_subresource_layout_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::DeviceImageSubresourceInfo<'_>,
		arg_2: *mut vk::SubresourceLayout2<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::DeviceImageSubresourceInfo<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::SubresourceLayout2<'_>,
				)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetDeviceImageSubresourceLayout = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetDeviceImageSubresourceLayout,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkGetDeviceImageSubresourceLayout", erased);
		let resolutions = Fixture::query_count();
		vk::get_device_image_subresource_layout(
			&fixture.device,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::DeviceImageSubresourceInfo<'_>,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *mut vk::SubresourceLayout2<'_>,
		)
		.unwrap();
		vk::Device::get_device_image_subresource_layout(
			&fixture.device,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::DeviceImageSubresourceInfo<'_>,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *mut vk::SubresourceLayout2<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_device_image_subresource_layout_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::DeviceImageSubresourceInfo<'_>,
		*mut vk::SubresourceLayout2<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::get_device_image_subresource_layout_khr;
	let _: Signature = vk::Device::get_device_image_subresource_layout_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_device_image_subresource_layout_khr(
				&fixture.device,
				std::mem::zeroed::<*const vk::DeviceImageSubresourceInfo<'_>>(),
				std::mem::zeroed::<*mut vk::SubresourceLayout2<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetDeviceImageSubresourceLayoutKHR"
			))
		));
		assert!(matches!(
			fixture.device.get_device_image_subresource_layout_khr(
				std::mem::zeroed::<*const vk::DeviceImageSubresourceInfo<'_>>(),
				std::mem::zeroed::<*mut vk::SubresourceLayout2<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetDeviceImageSubresourceLayoutKHR"
			))
		));
	}
}

#[test]
fn get_device_image_subresource_layout_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::DeviceImageSubresourceInfo<'_>,
		arg_2: *mut vk::SubresourceLayout2<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::DeviceImageSubresourceInfo<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::SubresourceLayout2<'_>,
				)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetDeviceImageSubresourceLayoutKHR = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetDeviceImageSubresourceLayoutKHR,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkGetDeviceImageSubresourceLayoutKHR", erased);
		let resolutions = Fixture::query_count();
		vk::get_device_image_subresource_layout_khr(
			&fixture.device,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::DeviceImageSubresourceInfo<'_>,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *mut vk::SubresourceLayout2<'_>,
		)
		.unwrap();
		vk::Device::get_device_image_subresource_layout_khr(
			&fixture.device,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::DeviceImageSubresourceInfo<'_>,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *mut vk::SubresourceLayout2<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn map_memory2_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::MemoryMapInfo<'_>,
		*mut *mut std::ffi::c_void,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::map_memory2;
	let _: Signature = vk::Device::map_memory2;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::map_memory2(
				&fixture.device,
				std::mem::zeroed::<*const vk::MemoryMapInfo<'_>>(),
				std::mem::zeroed::<*mut *mut std::ffi::c_void>()
			),
			Err(CallError::MissingCommand("vkMapMemory2"))
		));
		assert!(matches!(
			fixture.device.map_memory2(
				std::mem::zeroed::<*const vk::MemoryMapInfo<'_>>(),
				std::mem::zeroed::<*mut *mut std::ffi::c_void>()
			),
			Err(CallError::MissingCommand("vkMapMemory2"))
		));
	}
}

#[test]
fn map_memory2_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::MemoryMapInfo<'_>,
		arg_2: *mut *mut std::ffi::c_void,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::MemoryMapInfo<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut *mut std::ffi::c_void,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkMapMemory2 = Some(mock);
		let erased = std::mem::transmute::<vk::PFN_vkMapMemory2, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkMapMemory2", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::map_memory2(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::MemoryMapInfo<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut *mut std::ffi::c_void
				),
				expected
			);
			assert_eq!(
				vk::Device::map_memory2(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::MemoryMapInfo<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut *mut std::ffi::c_void
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn map_memory2_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::MemoryMapInfo<'_>,
		*mut *mut std::ffi::c_void,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::map_memory2_khr;
	let _: Signature = vk::Device::map_memory2_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::map_memory2_khr(
				&fixture.device,
				std::mem::zeroed::<*const vk::MemoryMapInfo<'_>>(),
				std::mem::zeroed::<*mut *mut std::ffi::c_void>()
			),
			Err(CallError::MissingCommand("vkMapMemory2KHR"))
		));
		assert!(matches!(
			fixture.device.map_memory2_khr(
				std::mem::zeroed::<*const vk::MemoryMapInfo<'_>>(),
				std::mem::zeroed::<*mut *mut std::ffi::c_void>()
			),
			Err(CallError::MissingCommand("vkMapMemory2KHR"))
		));
	}
}

#[test]
fn map_memory2_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::MemoryMapInfo<'_>,
		arg_2: *mut *mut std::ffi::c_void,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::MemoryMapInfo<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut *mut std::ffi::c_void,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkMapMemory2KHR = Some(mock);
		let erased = std::mem::transmute::<vk::PFN_vkMapMemory2KHR, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkMapMemory2KHR", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::map_memory2_khr(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::MemoryMapInfo<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut *mut std::ffi::c_void
				),
				expected
			);
			assert_eq!(
				vk::Device::map_memory2_khr(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::MemoryMapInfo<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut *mut std::ffi::c_void
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn unmap_memory2_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, *const vk::MemoryUnmapInfo<'_>) -> Result<vk::Result, CallError>;
	let _: Signature = vk::unmap_memory2;
	let _: Signature = vk::Device::unmap_memory2;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::unmap_memory2(
				&fixture.device,
				std::mem::zeroed::<*const vk::MemoryUnmapInfo<'_>>()
			),
			Err(CallError::MissingCommand("vkUnmapMemory2"))
		));
		assert!(matches!(
			fixture
				.device
				.unmap_memory2(std::mem::zeroed::<*const vk::MemoryUnmapInfo<'_>>()),
			Err(CallError::MissingCommand("vkUnmapMemory2"))
		));
	}
}

#[test]
fn unmap_memory2_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::MemoryUnmapInfo<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::MemoryUnmapInfo<'_>,
					)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkUnmapMemory2 = Some(mock);
		let erased = std::mem::transmute::<vk::PFN_vkUnmapMemory2, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkUnmapMemory2", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::unmap_memory2(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::MemoryUnmapInfo<'_>
				),
				expected
			);
			assert_eq!(
				vk::Device::unmap_memory2(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::MemoryUnmapInfo<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn unmap_memory2_khr_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, *const vk::MemoryUnmapInfo<'_>) -> Result<vk::Result, CallError>;
	let _: Signature = vk::unmap_memory2_khr;
	let _: Signature = vk::Device::unmap_memory2_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::unmap_memory2_khr(
				&fixture.device,
				std::mem::zeroed::<*const vk::MemoryUnmapInfo<'_>>()
			),
			Err(CallError::MissingCommand("vkUnmapMemory2KHR"))
		));
		assert!(matches!(
			fixture
				.device
				.unmap_memory2_khr(std::mem::zeroed::<*const vk::MemoryUnmapInfo<'_>>()),
			Err(CallError::MissingCommand("vkUnmapMemory2KHR"))
		));
	}
}

#[test]
fn unmap_memory2_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::MemoryUnmapInfo<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::MemoryUnmapInfo<'_>,
					)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkUnmapMemory2KHR = Some(mock);
		let erased = std::mem::transmute::<vk::PFN_vkUnmapMemory2KHR, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkUnmapMemory2KHR", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::unmap_memory2_khr(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::MemoryUnmapInfo<'_>
				),
				expected
			);
			assert_eq!(
				vk::Device::unmap_memory2_khr(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::MemoryUnmapInfo<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn create_shaders_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		u32,
		*const vk::ShaderCreateInfoEXT<'_>,
		*const vk::AllocationCallbacks,
		*mut vk::ShaderEXT,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::create_shaders_ext;
	let _: Signature = vk::Device::create_shaders_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::create_shaders_ext(
				&fixture.device,
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::ShaderCreateInfoEXT<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::ShaderEXT>()
			),
			Err(CallError::MissingCommand("vkCreateShadersEXT"))
		));
		assert!(matches!(
			fixture.device.create_shaders_ext(
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::ShaderCreateInfoEXT<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::ShaderEXT>()
			),
			Err(CallError::MissingCommand("vkCreateShadersEXT"))
		));
	}
}

#[test]
fn create_shaders_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: u32,
		arg_2: *const vk::ShaderCreateInfoEXT<'_>,
		arg_3: *const vk::AllocationCallbacks,
		arg_4: *mut vk::ShaderEXT,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == Default::default()
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *const vk::ShaderCreateInfoEXT<'_>,
					) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *const vk::AllocationCallbacks,
				) && std::ptr::eq(
					arg_4,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784) as *mut vk::ShaderEXT,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCreateShadersEXT = Some(mock);
		let erased = std::mem::transmute::<vk::PFN_vkCreateShadersEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCreateShadersEXT", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::create_shaders_ext(
					&fixture.device,
					Default::default(),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::ShaderCreateInfoEXT<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784) as *mut vk::ShaderEXT
				),
				expected
			);
			assert_eq!(
				vk::Device::create_shaders_ext(
					&fixture.device,
					Default::default(),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::ShaderCreateInfoEXT<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784) as *mut vk::ShaderEXT
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn destroy_shader_ext_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, vk::ShaderEXT, *const vk::AllocationCallbacks) -> Result<(), CallError>;
	let _: Signature = vk::destroy_shader_ext;
	let _: Signature = vk::Device::destroy_shader_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::destroy_shader_ext(
				&fixture.device,
				std::mem::zeroed::<vk::ShaderEXT>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>()
			),
			Err(CallError::MissingCommand("vkDestroyShaderEXT"))
		));
		assert!(matches!(
			fixture.device.destroy_shader_ext(
				std::mem::zeroed::<vk::ShaderEXT>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>()
			),
			Err(CallError::MissingCommand("vkDestroyShaderEXT"))
		));
	}
}

#[test]
fn destroy_shader_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::ShaderEXT,
		arg_2: *const vk::AllocationCallbacks,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::ShaderEXT::from_raw(305398016_u64 as _)
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *const vk::AllocationCallbacks,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkDestroyShaderEXT = Some(mock);
		let erased = std::mem::transmute::<vk::PFN_vkDestroyShaderEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkDestroyShaderEXT", erased);
		let resolutions = Fixture::query_count();
		vk::destroy_shader_ext(
			&fixture.device,
			vk::ShaderEXT::from_raw(305398016_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::AllocationCallbacks,
		)
		.unwrap();
		vk::Device::destroy_shader_ext(
			&fixture.device,
			vk::ShaderEXT::from_raw(305398016_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::AllocationCallbacks,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_shader_binary_data_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::ShaderEXT,
		*mut usize,
		*mut std::ffi::c_void,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_shader_binary_data_ext;
	let _: Signature = vk::Device::get_shader_binary_data_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_shader_binary_data_ext(
				&fixture.device,
				std::mem::zeroed::<vk::ShaderEXT>(),
				std::mem::zeroed::<*mut usize>(),
				std::mem::zeroed::<*mut std::ffi::c_void>()
			),
			Err(CallError::MissingCommand("vkGetShaderBinaryDataEXT"))
		));
		assert!(matches!(
			fixture.device.get_shader_binary_data_ext(
				std::mem::zeroed::<vk::ShaderEXT>(),
				std::mem::zeroed::<*mut usize>(),
				std::mem::zeroed::<*mut std::ffi::c_void>()
			),
			Err(CallError::MissingCommand("vkGetShaderBinaryDataEXT"))
		));
	}
}

#[test]
fn get_shader_binary_data_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::ShaderEXT,
		arg_2: *mut usize,
		arg_3: *mut std::ffi::c_void,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::ShaderEXT::from_raw(305398016_u64 as _)
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut usize,
					) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528),
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetShaderBinaryDataEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkGetShaderBinaryDataEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkGetShaderBinaryDataEXT", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_shader_binary_data_ext(
					&fixture.device,
					vk::ShaderEXT::from_raw(305398016_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut usize,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
				),
				expected
			);
			assert_eq!(
				vk::Device::get_shader_binary_data_ext(
					&fixture.device,
					vk::ShaderEXT::from_raw(305398016_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut usize,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_bind_shaders_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		u32,
		*const vk::ShaderStageFlagBits,
		*const vk::ShaderEXT,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_bind_shaders_ext;
	let _: Signature = vk::Device::cmd_bind_shaders_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_bind_shaders_ext(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::ShaderStageFlagBits>(),
				std::mem::zeroed::<*const vk::ShaderEXT>()
			),
			Err(CallError::MissingCommand("vkCmdBindShadersEXT"))
		));
		assert!(matches!(
			fixture.device.cmd_bind_shaders_ext(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::ShaderStageFlagBits>(),
				std::mem::zeroed::<*const vk::ShaderEXT>()
			),
			Err(CallError::MissingCommand("vkCmdBindShadersEXT"))
		));
	}
}

#[test]
fn cmd_bind_shaders_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: u32,
		arg_2: *const vk::ShaderStageFlagBits,
		arg_3: *const vk::ShaderEXT,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == Default::default()
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *const vk::ShaderStageFlagBits,
					) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *const vk::ShaderEXT,
				)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdBindShadersEXT = Some(mock);
		let erased = std::mem::transmute::<vk::PFN_vkCmdBindShadersEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdBindShadersEXT", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_bind_shaders_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::ShaderStageFlagBits,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *const vk::ShaderEXT,
		)
		.unwrap();
		vk::Device::cmd_bind_shaders_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::ShaderStageFlagBits,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *const vk::ShaderEXT,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn set_swapchain_present_timing_queue_size_ext_signature_and_missing_command() {
	type Signature = unsafe fn(&vk::Device, vk::SwapchainKHR, u32) -> Result<vk::Result, CallError>;
	let _: Signature = vk::set_swapchain_present_timing_queue_size_ext;
	let _: Signature = vk::Device::set_swapchain_present_timing_queue_size_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::set_swapchain_present_timing_queue_size_ext(
				&fixture.device,
				std::mem::zeroed::<vk::SwapchainKHR>(),
				std::mem::zeroed::<u32>()
			),
			Err(CallError::MissingCommand(
				"vkSetSwapchainPresentTimingQueueSizeEXT"
			))
		));
		assert!(matches!(
			fixture.device.set_swapchain_present_timing_queue_size_ext(
				std::mem::zeroed::<vk::SwapchainKHR>(),
				std::mem::zeroed::<u32>()
			),
			Err(CallError::MissingCommand(
				"vkSetSwapchainPresentTimingQueueSizeEXT"
			))
		));
	}
}

#[test]
fn set_swapchain_present_timing_queue_size_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::SwapchainKHR,
		arg_2: u32,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::SwapchainKHR::from_raw(305398016_u64 as _)
					&& arg_2 == Default::default()),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkSetSwapchainPresentTimingQueueSizeEXT = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkSetSwapchainPresentTimingQueueSizeEXT,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkSetSwapchainPresentTimingQueueSizeEXT", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::set_swapchain_present_timing_queue_size_ext(
					&fixture.device,
					vk::SwapchainKHR::from_raw(305398016_u64 as _),
					Default::default()
				),
				expected
			);
			assert_eq!(
				vk::Device::set_swapchain_present_timing_queue_size_ext(
					&fixture.device,
					vk::SwapchainKHR::from_raw(305398016_u64 as _),
					Default::default()
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_swapchain_timing_properties_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::SwapchainKHR,
		*mut vk::SwapchainTimingPropertiesEXT<'_>,
		*mut u64,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_swapchain_timing_properties_ext;
	let _: Signature = vk::Device::get_swapchain_timing_properties_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_swapchain_timing_properties_ext(
				&fixture.device,
				std::mem::zeroed::<vk::SwapchainKHR>(),
				std::mem::zeroed::<*mut vk::SwapchainTimingPropertiesEXT<'_>>(),
				std::mem::zeroed::<*mut u64>()
			),
			Err(CallError::MissingCommand(
				"vkGetSwapchainTimingPropertiesEXT"
			))
		));
		assert!(matches!(
			fixture.device.get_swapchain_timing_properties_ext(
				std::mem::zeroed::<vk::SwapchainKHR>(),
				std::mem::zeroed::<*mut vk::SwapchainTimingPropertiesEXT<'_>>(),
				std::mem::zeroed::<*mut u64>()
			),
			Err(CallError::MissingCommand(
				"vkGetSwapchainTimingPropertiesEXT"
			))
		));
	}
}

#[test]
fn get_swapchain_timing_properties_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::SwapchainKHR,
		arg_2: *mut vk::SwapchainTimingPropertiesEXT<'_>,
		arg_3: *mut u64,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::SwapchainKHR::from_raw(305398016_u64 as _)
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *mut vk::SwapchainTimingPropertiesEXT<'_>,
					) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut u64,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetSwapchainTimingPropertiesEXT = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetSwapchainTimingPropertiesEXT,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkGetSwapchainTimingPropertiesEXT", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_swapchain_timing_properties_ext(
					&fixture.device,
					vk::SwapchainKHR::from_raw(305398016_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::SwapchainTimingPropertiesEXT<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut u64
				),
				expected
			);
			assert_eq!(
				vk::Device::get_swapchain_timing_properties_ext(
					&fixture.device,
					vk::SwapchainKHR::from_raw(305398016_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::SwapchainTimingPropertiesEXT<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut u64
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_swapchain_time_domain_properties_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::SwapchainKHR,
		*mut vk::SwapchainTimeDomainPropertiesEXT<'_>,
		*mut u64,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_swapchain_time_domain_properties_ext;
	let _: Signature = vk::Device::get_swapchain_time_domain_properties_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_swapchain_time_domain_properties_ext(
				&fixture.device,
				std::mem::zeroed::<vk::SwapchainKHR>(),
				std::mem::zeroed::<*mut vk::SwapchainTimeDomainPropertiesEXT<'_>>(),
				std::mem::zeroed::<*mut u64>()
			),
			Err(CallError::MissingCommand(
				"vkGetSwapchainTimeDomainPropertiesEXT"
			))
		));
		assert!(matches!(
			fixture.device.get_swapchain_time_domain_properties_ext(
				std::mem::zeroed::<vk::SwapchainKHR>(),
				std::mem::zeroed::<*mut vk::SwapchainTimeDomainPropertiesEXT<'_>>(),
				std::mem::zeroed::<*mut u64>()
			),
			Err(CallError::MissingCommand(
				"vkGetSwapchainTimeDomainPropertiesEXT"
			))
		));
	}
}

#[test]
fn get_swapchain_time_domain_properties_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::SwapchainKHR,
		arg_2: *mut vk::SwapchainTimeDomainPropertiesEXT<'_>,
		arg_3: *mut u64,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::SwapchainKHR::from_raw(305398016_u64 as _)
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *mut vk::SwapchainTimeDomainPropertiesEXT<'_>,
					) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut u64,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetSwapchainTimeDomainPropertiesEXT = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetSwapchainTimeDomainPropertiesEXT,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkGetSwapchainTimeDomainPropertiesEXT", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_swapchain_time_domain_properties_ext(
					&fixture.device,
					vk::SwapchainKHR::from_raw(305398016_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::SwapchainTimeDomainPropertiesEXT<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut u64
				),
				expected
			);
			assert_eq!(
				vk::Device::get_swapchain_time_domain_properties_ext(
					&fixture.device,
					vk::SwapchainKHR::from_raw(305398016_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::SwapchainTimeDomainPropertiesEXT<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut u64
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_past_presentation_timing_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::PastPresentationTimingInfoEXT<'_>,
		*mut vk::PastPresentationTimingPropertiesEXT<'_>,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_past_presentation_timing_ext;
	let _: Signature = vk::Device::get_past_presentation_timing_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_past_presentation_timing_ext(
				&fixture.device,
				std::mem::zeroed::<*const vk::PastPresentationTimingInfoEXT<'_>>(),
				std::mem::zeroed::<*mut vk::PastPresentationTimingPropertiesEXT<'_>>()
			),
			Err(CallError::MissingCommand("vkGetPastPresentationTimingEXT"))
		));
		assert!(matches!(
			fixture.device.get_past_presentation_timing_ext(
				std::mem::zeroed::<*const vk::PastPresentationTimingInfoEXT<'_>>(),
				std::mem::zeroed::<*mut vk::PastPresentationTimingPropertiesEXT<'_>>()
			),
			Err(CallError::MissingCommand("vkGetPastPresentationTimingEXT"))
		));
	}
}

#[test]
fn get_past_presentation_timing_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::PastPresentationTimingInfoEXT<'_>,
		arg_2: *mut vk::PastPresentationTimingPropertiesEXT<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::PastPresentationTimingInfoEXT<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::PastPresentationTimingPropertiesEXT<'_>,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetPastPresentationTimingEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkGetPastPresentationTimingEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkGetPastPresentationTimingEXT", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_past_presentation_timing_ext(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::PastPresentationTimingInfoEXT<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::PastPresentationTimingPropertiesEXT<'_>
				),
				expected
			);
			assert_eq!(
				vk::Device::get_past_presentation_timing_ext(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::PastPresentationTimingInfoEXT<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::PastPresentationTimingPropertiesEXT<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[cfg(feature = "platform-screen")]
#[test]
fn get_screen_buffer_properties_qnx_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::_screen_buffer,
		*mut vk::ScreenBufferPropertiesQNX<'_>,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_screen_buffer_properties_qnx;
	let _: Signature = vk::Device::get_screen_buffer_properties_qnx;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_screen_buffer_properties_qnx(
				&fixture.device,
				std::mem::zeroed::<*const vk::_screen_buffer>(),
				std::mem::zeroed::<*mut vk::ScreenBufferPropertiesQNX<'_>>()
			),
			Err(CallError::MissingCommand("vkGetScreenBufferPropertiesQNX"))
		));
		assert!(matches!(
			fixture.device.get_screen_buffer_properties_qnx(
				std::mem::zeroed::<*const vk::_screen_buffer>(),
				std::mem::zeroed::<*mut vk::ScreenBufferPropertiesQNX<'_>>()
			),
			Err(CallError::MissingCommand("vkGetScreenBufferPropertiesQNX"))
		));
	}
}

#[cfg(feature = "platform-screen")]
#[test]
fn get_screen_buffer_properties_qnx_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::_screen_buffer,
		arg_2: *mut vk::ScreenBufferPropertiesQNX<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::_screen_buffer,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::ScreenBufferPropertiesQNX<'_>,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetScreenBufferPropertiesQNX = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkGetScreenBufferPropertiesQNX, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkGetScreenBufferPropertiesQNX", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_screen_buffer_properties_qnx(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::_screen_buffer,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::ScreenBufferPropertiesQNX<'_>
				),
				expected
			);
			assert_eq!(
				vk::Device::get_screen_buffer_properties_qnx(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::_screen_buffer,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::ScreenBufferPropertiesQNX<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_physical_device_cooperative_matrix_properties_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		vk::PhysicalDevice,
		*mut u32,
		*mut vk::CooperativeMatrixPropertiesKHR<'_>,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_physical_device_cooperative_matrix_properties_khr;
	let _: Signature = vk::Instance::get_physical_device_cooperative_matrix_properties_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_physical_device_cooperative_matrix_properties_khr(
				&fixture.instance,
				std::mem::zeroed::<vk::PhysicalDevice>(),
				std::mem::zeroed::<*mut u32>(),
				std::mem::zeroed::<*mut vk::CooperativeMatrixPropertiesKHR<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR"
			))
		));
		assert!(matches!(
			fixture
				.instance
				.get_physical_device_cooperative_matrix_properties_khr(
					std::mem::zeroed::<vk::PhysicalDevice>(),
					std::mem::zeroed::<*mut u32>(),
					std::mem::zeroed::<*mut vk::CooperativeMatrixPropertiesKHR<'_>>()
				),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR"
			))
		));
	}
}

#[test]
fn get_physical_device_cooperative_matrix_properties_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::PhysicalDevice,
		arg_1: *mut u32,
		arg_2: *mut vk::CooperativeMatrixPropertiesKHR<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::PhysicalDevice::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016) as *mut u32,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::CooperativeMatrixPropertiesKHR<'_>,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture =
			Fixture::new_with_command(c"vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_physical_device_cooperative_matrix_properties_khr(
					&fixture.instance,
					vk::PhysicalDevice::from_raw(305397760_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016) as *mut u32,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::CooperativeMatrixPropertiesKHR<'_>
				),
				expected
			);
			assert_eq!(
				vk::Instance::get_physical_device_cooperative_matrix_properties_khr(
					&fixture.instance,
					vk::PhysicalDevice::from_raw(305397760_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016) as *mut u32,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::CooperativeMatrixPropertiesKHR<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_physical_device_cooperative_matrix_properties2_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		vk::PhysicalDevice,
		*const vk::PhysicalDeviceCooperativeMatrixInfo2EXT<'_>,
		*mut u32,
		*mut vk::CooperativeMatrixProperties2EXT<'_>,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_physical_device_cooperative_matrix_properties2_ext;
	let _: Signature = vk::Instance::get_physical_device_cooperative_matrix_properties2_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_physical_device_cooperative_matrix_properties2_ext(
				&fixture.instance,
				std::mem::zeroed::<vk::PhysicalDevice>(),
				std::mem::zeroed::<*const vk::PhysicalDeviceCooperativeMatrixInfo2EXT<'_>>(),
				std::mem::zeroed::<*mut u32>(),
				std::mem::zeroed::<*mut vk::CooperativeMatrixProperties2EXT<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceCooperativeMatrixProperties2EXT"
			))
		));
		assert!(matches!(
			fixture
				.instance
				.get_physical_device_cooperative_matrix_properties2_ext(
					std::mem::zeroed::<vk::PhysicalDevice>(),
					std::mem::zeroed::<*const vk::PhysicalDeviceCooperativeMatrixInfo2EXT<'_>>(),
					std::mem::zeroed::<*mut u32>(),
					std::mem::zeroed::<*mut vk::CooperativeMatrixProperties2EXT<'_>>()
				),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceCooperativeMatrixProperties2EXT"
			))
		));
	}
}

#[test]
fn get_physical_device_cooperative_matrix_properties2_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::PhysicalDevice,
		arg_1: *const vk::PhysicalDeviceCooperativeMatrixInfo2EXT<'_>,
		arg_2: *mut u32,
		arg_3: *mut vk::CooperativeMatrixProperties2EXT<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::PhysicalDevice::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::PhysicalDeviceCooperativeMatrixInfo2EXT<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut u32,
				) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::CooperativeMatrixProperties2EXT<'_>,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetPhysicalDeviceCooperativeMatrixProperties2EXT = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetPhysicalDeviceCooperativeMatrixProperties2EXT,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(
			c"vkGetPhysicalDeviceCooperativeMatrixProperties2EXT",
			erased,
		);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_physical_device_cooperative_matrix_properties2_ext(
					&fixture.instance,
					vk::PhysicalDevice::from_raw(305397760_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::PhysicalDeviceCooperativeMatrixInfo2EXT<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut u32,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::CooperativeMatrixProperties2EXT<'_>
				),
				expected
			);
			assert_eq!(
				vk::Instance::get_physical_device_cooperative_matrix_properties2_ext(
					&fixture.instance,
					vk::PhysicalDevice::from_raw(305397760_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::PhysicalDeviceCooperativeMatrixInfo2EXT<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut u32,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::CooperativeMatrixProperties2EXT<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[cfg(feature = "provisional")]
#[test]
fn get_execution_graph_pipeline_scratch_size_amdx_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::Pipeline,
		*mut vk::ExecutionGraphPipelineScratchSizeAMDX<'_>,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_execution_graph_pipeline_scratch_size_amdx;
	let _: Signature = vk::Device::get_execution_graph_pipeline_scratch_size_amdx;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_execution_graph_pipeline_scratch_size_amdx(
				&fixture.device,
				std::mem::zeroed::<vk::Pipeline>(),
				std::mem::zeroed::<*mut vk::ExecutionGraphPipelineScratchSizeAMDX<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetExecutionGraphPipelineScratchSizeAMDX"
			))
		));
		assert!(matches!(
			fixture
				.device
				.get_execution_graph_pipeline_scratch_size_amdx(
					std::mem::zeroed::<vk::Pipeline>(),
					std::mem::zeroed::<*mut vk::ExecutionGraphPipelineScratchSizeAMDX<'_>>()
				),
			Err(CallError::MissingCommand(
				"vkGetExecutionGraphPipelineScratchSizeAMDX"
			))
		));
	}
}

#[cfg(feature = "provisional")]
#[test]
fn get_execution_graph_pipeline_scratch_size_amdx_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::Pipeline,
		arg_2: *mut vk::ExecutionGraphPipelineScratchSizeAMDX<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::Pipeline::from_raw(305398016_u64 as _)
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *mut vk::ExecutionGraphPipelineScratchSizeAMDX<'_>,
					)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetExecutionGraphPipelineScratchSizeAMDX = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetExecutionGraphPipelineScratchSizeAMDX,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkGetExecutionGraphPipelineScratchSizeAMDX", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_execution_graph_pipeline_scratch_size_amdx(
					&fixture.device,
					vk::Pipeline::from_raw(305398016_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::ExecutionGraphPipelineScratchSizeAMDX<'_>
				),
				expected
			);
			assert_eq!(
				vk::Device::get_execution_graph_pipeline_scratch_size_amdx(
					&fixture.device,
					vk::Pipeline::from_raw(305398016_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::ExecutionGraphPipelineScratchSizeAMDX<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[cfg(feature = "provisional")]
#[test]
fn get_execution_graph_pipeline_node_index_amdx_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::Pipeline,
		*const vk::PipelineShaderStageNodeCreateInfoAMDX<'_>,
		*mut u32,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_execution_graph_pipeline_node_index_amdx;
	let _: Signature = vk::Device::get_execution_graph_pipeline_node_index_amdx;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_execution_graph_pipeline_node_index_amdx(
				&fixture.device,
				std::mem::zeroed::<vk::Pipeline>(),
				std::mem::zeroed::<*const vk::PipelineShaderStageNodeCreateInfoAMDX<'_>>(),
				std::mem::zeroed::<*mut u32>()
			),
			Err(CallError::MissingCommand(
				"vkGetExecutionGraphPipelineNodeIndexAMDX"
			))
		));
		assert!(matches!(
			fixture.device.get_execution_graph_pipeline_node_index_amdx(
				std::mem::zeroed::<vk::Pipeline>(),
				std::mem::zeroed::<*const vk::PipelineShaderStageNodeCreateInfoAMDX<'_>>(),
				std::mem::zeroed::<*mut u32>()
			),
			Err(CallError::MissingCommand(
				"vkGetExecutionGraphPipelineNodeIndexAMDX"
			))
		));
	}
}

#[cfg(feature = "provisional")]
#[test]
fn get_execution_graph_pipeline_node_index_amdx_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::Pipeline,
		arg_2: *const vk::PipelineShaderStageNodeCreateInfoAMDX<'_>,
		arg_3: *mut u32,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::Pipeline::from_raw(305398016_u64 as _)
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *const vk::PipelineShaderStageNodeCreateInfoAMDX<'_>,
					) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut u32,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetExecutionGraphPipelineNodeIndexAMDX = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetExecutionGraphPipelineNodeIndexAMDX,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkGetExecutionGraphPipelineNodeIndexAMDX", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_execution_graph_pipeline_node_index_amdx(
					&fixture.device,
					vk::Pipeline::from_raw(305398016_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::PipelineShaderStageNodeCreateInfoAMDX<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut u32
				),
				expected
			);
			assert_eq!(
				vk::Device::get_execution_graph_pipeline_node_index_amdx(
					&fixture.device,
					vk::Pipeline::from_raw(305398016_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::PipelineShaderStageNodeCreateInfoAMDX<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut u32
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[cfg(feature = "provisional")]
#[test]
fn create_execution_graph_pipelines_amdx_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::PipelineCache,
		u32,
		*const vk::ExecutionGraphPipelineCreateInfoAMDX<'_>,
		*const vk::AllocationCallbacks,
		*mut vk::Pipeline,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::create_execution_graph_pipelines_amdx;
	let _: Signature = vk::Device::create_execution_graph_pipelines_amdx;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::create_execution_graph_pipelines_amdx(
				&fixture.device,
				std::mem::zeroed::<vk::PipelineCache>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::ExecutionGraphPipelineCreateInfoAMDX<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::Pipeline>()
			),
			Err(CallError::MissingCommand(
				"vkCreateExecutionGraphPipelinesAMDX"
			))
		));
		assert!(matches!(
			fixture.device.create_execution_graph_pipelines_amdx(
				std::mem::zeroed::<vk::PipelineCache>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::ExecutionGraphPipelineCreateInfoAMDX<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::Pipeline>()
			),
			Err(CallError::MissingCommand(
				"vkCreateExecutionGraphPipelinesAMDX"
			))
		));
	}
}

#[cfg(feature = "provisional")]
#[test]
fn create_execution_graph_pipelines_amdx_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::PipelineCache,
		arg_2: u32,
		arg_3: *const vk::ExecutionGraphPipelineCreateInfoAMDX<'_>,
		arg_4: *const vk::AllocationCallbacks,
		arg_5: *mut vk::Pipeline,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::PipelineCache::from_raw(305398016_u64 as _)
					&& arg_2 == Default::default()
					&& std::ptr::eq(
						arg_3,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
							as *const vk::ExecutionGraphPipelineCreateInfoAMDX<'_>,
					) && std::ptr::eq(
					arg_4,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784)
						as *const vk::AllocationCallbacks,
				) && std::ptr::eq(
					arg_5,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305399040) as *mut vk::Pipeline,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCreateExecutionGraphPipelinesAMDX = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkCreateExecutionGraphPipelinesAMDX,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkCreateExecutionGraphPipelinesAMDX", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::create_execution_graph_pipelines_amdx(
					&fixture.device,
					vk::PipelineCache::from_raw(305398016_u64 as _),
					Default::default(),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *const vk::ExecutionGraphPipelineCreateInfoAMDX<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305399040) as *mut vk::Pipeline
				),
				expected
			);
			assert_eq!(
				vk::Device::create_execution_graph_pipelines_amdx(
					&fixture.device,
					vk::PipelineCache::from_raw(305398016_u64 as _),
					Default::default(),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *const vk::ExecutionGraphPipelineCreateInfoAMDX<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305399040) as *mut vk::Pipeline
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[cfg(feature = "provisional")]
#[test]
fn cmd_initialize_graph_scratch_memory_amdx_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		vk::Pipeline,
		vk::DeviceAddress,
		vk::DeviceSize,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_initialize_graph_scratch_memory_amdx;
	let _: Signature = vk::Device::cmd_initialize_graph_scratch_memory_amdx;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_initialize_graph_scratch_memory_amdx(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::Pipeline>(),
				std::mem::zeroed::<vk::DeviceAddress>(),
				std::mem::zeroed::<vk::DeviceSize>()
			),
			Err(CallError::MissingCommand(
				"vkCmdInitializeGraphScratchMemoryAMDX"
			))
		));
		assert!(matches!(
			fixture.device.cmd_initialize_graph_scratch_memory_amdx(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::Pipeline>(),
				std::mem::zeroed::<vk::DeviceAddress>(),
				std::mem::zeroed::<vk::DeviceSize>()
			),
			Err(CallError::MissingCommand(
				"vkCmdInitializeGraphScratchMemoryAMDX"
			))
		));
	}
}

#[cfg(feature = "provisional")]
#[test]
fn cmd_initialize_graph_scratch_memory_amdx_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: vk::Pipeline,
		arg_2: vk::DeviceAddress,
		arg_3: vk::DeviceSize,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == vk::Pipeline::from_raw(305398016_u64 as _)
					&& arg_2 == 305398272_u64 as vk::DeviceAddress
					&& arg_3 == 305398528_u64 as vk::DeviceSize),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdInitializeGraphScratchMemoryAMDX = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkCmdInitializeGraphScratchMemoryAMDX,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdInitializeGraphScratchMemoryAMDX", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_initialize_graph_scratch_memory_amdx(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::Pipeline::from_raw(305398016_u64 as _),
			305398272_u64 as vk::DeviceAddress,
			305398528_u64 as vk::DeviceSize,
		)
		.unwrap();
		vk::Device::cmd_initialize_graph_scratch_memory_amdx(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::Pipeline::from_raw(305398016_u64 as _),
			305398272_u64 as vk::DeviceAddress,
			305398528_u64 as vk::DeviceSize,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[cfg(feature = "provisional")]
#[test]
fn cmd_dispatch_graph_amdx_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		vk::DeviceAddress,
		vk::DeviceSize,
		*const vk::DispatchGraphCountInfoAMDX,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_dispatch_graph_amdx;
	let _: Signature = vk::Device::cmd_dispatch_graph_amdx;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_dispatch_graph_amdx(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::DeviceAddress>(),
				std::mem::zeroed::<vk::DeviceSize>(),
				std::mem::zeroed::<*const vk::DispatchGraphCountInfoAMDX>()
			),
			Err(CallError::MissingCommand("vkCmdDispatchGraphAMDX"))
		));
		assert!(matches!(
			fixture.device.cmd_dispatch_graph_amdx(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::DeviceAddress>(),
				std::mem::zeroed::<vk::DeviceSize>(),
				std::mem::zeroed::<*const vk::DispatchGraphCountInfoAMDX>()
			),
			Err(CallError::MissingCommand("vkCmdDispatchGraphAMDX"))
		));
	}
}

#[cfg(feature = "provisional")]
#[test]
fn cmd_dispatch_graph_amdx_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: vk::DeviceAddress,
		arg_2: vk::DeviceSize,
		arg_3: *const vk::DispatchGraphCountInfoAMDX,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == 305398016_u64 as vk::DeviceAddress
					&& arg_2 == 305398272_u64 as vk::DeviceSize
					&& std::ptr::eq(
						arg_3,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
							as *const vk::DispatchGraphCountInfoAMDX,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdDispatchGraphAMDX = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdDispatchGraphAMDX, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdDispatchGraphAMDX", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_dispatch_graph_amdx(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			305398016_u64 as vk::DeviceAddress,
			305398272_u64 as vk::DeviceSize,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
				as *const vk::DispatchGraphCountInfoAMDX,
		)
		.unwrap();
		vk::Device::cmd_dispatch_graph_amdx(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			305398016_u64 as vk::DeviceAddress,
			305398272_u64 as vk::DeviceSize,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
				as *const vk::DispatchGraphCountInfoAMDX,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[cfg(feature = "provisional")]
#[test]
fn cmd_dispatch_graph_indirect_amdx_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		vk::DeviceAddress,
		vk::DeviceSize,
		*const vk::DispatchGraphCountInfoAMDX,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_dispatch_graph_indirect_amdx;
	let _: Signature = vk::Device::cmd_dispatch_graph_indirect_amdx;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_dispatch_graph_indirect_amdx(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::DeviceAddress>(),
				std::mem::zeroed::<vk::DeviceSize>(),
				std::mem::zeroed::<*const vk::DispatchGraphCountInfoAMDX>()
			),
			Err(CallError::MissingCommand("vkCmdDispatchGraphIndirectAMDX"))
		));
		assert!(matches!(
			fixture.device.cmd_dispatch_graph_indirect_amdx(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::DeviceAddress>(),
				std::mem::zeroed::<vk::DeviceSize>(),
				std::mem::zeroed::<*const vk::DispatchGraphCountInfoAMDX>()
			),
			Err(CallError::MissingCommand("vkCmdDispatchGraphIndirectAMDX"))
		));
	}
}

#[cfg(feature = "provisional")]
#[test]
fn cmd_dispatch_graph_indirect_amdx_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: vk::DeviceAddress,
		arg_2: vk::DeviceSize,
		arg_3: *const vk::DispatchGraphCountInfoAMDX,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == 305398016_u64 as vk::DeviceAddress
					&& arg_2 == 305398272_u64 as vk::DeviceSize
					&& std::ptr::eq(
						arg_3,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
							as *const vk::DispatchGraphCountInfoAMDX,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdDispatchGraphIndirectAMDX = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdDispatchGraphIndirectAMDX, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdDispatchGraphIndirectAMDX", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_dispatch_graph_indirect_amdx(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			305398016_u64 as vk::DeviceAddress,
			305398272_u64 as vk::DeviceSize,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
				as *const vk::DispatchGraphCountInfoAMDX,
		)
		.unwrap();
		vk::Device::cmd_dispatch_graph_indirect_amdx(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			305398016_u64 as vk::DeviceAddress,
			305398272_u64 as vk::DeviceSize,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
				as *const vk::DispatchGraphCountInfoAMDX,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[cfg(feature = "provisional")]
#[test]
fn cmd_dispatch_graph_indirect_count_amdx_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		vk::DeviceAddress,
		vk::DeviceSize,
		vk::DeviceAddress,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_dispatch_graph_indirect_count_amdx;
	let _: Signature = vk::Device::cmd_dispatch_graph_indirect_count_amdx;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_dispatch_graph_indirect_count_amdx(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::DeviceAddress>(),
				std::mem::zeroed::<vk::DeviceSize>(),
				std::mem::zeroed::<vk::DeviceAddress>()
			),
			Err(CallError::MissingCommand(
				"vkCmdDispatchGraphIndirectCountAMDX"
			))
		));
		assert!(matches!(
			fixture.device.cmd_dispatch_graph_indirect_count_amdx(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::DeviceAddress>(),
				std::mem::zeroed::<vk::DeviceSize>(),
				std::mem::zeroed::<vk::DeviceAddress>()
			),
			Err(CallError::MissingCommand(
				"vkCmdDispatchGraphIndirectCountAMDX"
			))
		));
	}
}

#[cfg(feature = "provisional")]
#[test]
fn cmd_dispatch_graph_indirect_count_amdx_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: vk::DeviceAddress,
		arg_2: vk::DeviceSize,
		arg_3: vk::DeviceAddress,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == 305398016_u64 as vk::DeviceAddress
					&& arg_2 == 305398272_u64 as vk::DeviceSize
					&& arg_3 == 305398528_u64 as vk::DeviceAddress),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdDispatchGraphIndirectCountAMDX = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkCmdDispatchGraphIndirectCountAMDX,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdDispatchGraphIndirectCountAMDX", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_dispatch_graph_indirect_count_amdx(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			305398016_u64 as vk::DeviceAddress,
			305398272_u64 as vk::DeviceSize,
			305398528_u64 as vk::DeviceAddress,
		)
		.unwrap();
		vk::Device::cmd_dispatch_graph_indirect_count_amdx(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			305398016_u64 as vk::DeviceAddress,
			305398272_u64 as vk::DeviceSize,
			305398528_u64 as vk::DeviceAddress,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn create_gpa_session_amd_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::GpaSessionCreateInfoAMD<'_>,
		*const vk::AllocationCallbacks,
		*mut vk::GpaSessionAMD,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::create_gpa_session_amd;
	let _: Signature = vk::Device::create_gpa_session_amd;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::create_gpa_session_amd(
				&fixture.device,
				std::mem::zeroed::<*const vk::GpaSessionCreateInfoAMD<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::GpaSessionAMD>()
			),
			Err(CallError::MissingCommand("vkCreateGpaSessionAMD"))
		));
		assert!(matches!(
			fixture.device.create_gpa_session_amd(
				std::mem::zeroed::<*const vk::GpaSessionCreateInfoAMD<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::GpaSessionAMD>()
			),
			Err(CallError::MissingCommand("vkCreateGpaSessionAMD"))
		));
	}
}

#[test]
fn create_gpa_session_amd_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::GpaSessionCreateInfoAMD<'_>,
		arg_2: *const vk::AllocationCallbacks,
		arg_3: *mut vk::GpaSessionAMD,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::GpaSessionCreateInfoAMD<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
				) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::GpaSessionAMD,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCreateGpaSessionAMD = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCreateGpaSessionAMD, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCreateGpaSessionAMD", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::create_gpa_session_amd(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::GpaSessionCreateInfoAMD<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::GpaSessionAMD
				),
				expected
			);
			assert_eq!(
				vk::Device::create_gpa_session_amd(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::GpaSessionCreateInfoAMD<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::GpaSessionAMD
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn destroy_gpa_session_amd_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::GpaSessionAMD,
		*const vk::AllocationCallbacks,
	) -> Result<(), CallError>;
	let _: Signature = vk::destroy_gpa_session_amd;
	let _: Signature = vk::Device::destroy_gpa_session_amd;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::destroy_gpa_session_amd(
				&fixture.device,
				std::mem::zeroed::<vk::GpaSessionAMD>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>()
			),
			Err(CallError::MissingCommand("vkDestroyGpaSessionAMD"))
		));
		assert!(matches!(
			fixture.device.destroy_gpa_session_amd(
				std::mem::zeroed::<vk::GpaSessionAMD>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>()
			),
			Err(CallError::MissingCommand("vkDestroyGpaSessionAMD"))
		));
	}
}

#[test]
fn destroy_gpa_session_amd_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::GpaSessionAMD,
		arg_2: *const vk::AllocationCallbacks,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::GpaSessionAMD::from_raw(305398016_u64 as _)
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *const vk::AllocationCallbacks,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkDestroyGpaSessionAMD = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkDestroyGpaSessionAMD, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkDestroyGpaSessionAMD", erased);
		let resolutions = Fixture::query_count();
		vk::destroy_gpa_session_amd(
			&fixture.device,
			vk::GpaSessionAMD::from_raw(305398016_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::AllocationCallbacks,
		)
		.unwrap();
		vk::Device::destroy_gpa_session_amd(
			&fixture.device,
			vk::GpaSessionAMD::from_raw(305398016_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::AllocationCallbacks,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn set_gpa_device_clock_mode_amd_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, *mut vk::GpaDeviceClockModeInfoAMD<'_>) -> Result<vk::Result, CallError>;
	let _: Signature = vk::set_gpa_device_clock_mode_amd;
	let _: Signature = vk::Device::set_gpa_device_clock_mode_amd;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::set_gpa_device_clock_mode_amd(
				&fixture.device,
				std::mem::zeroed::<*mut vk::GpaDeviceClockModeInfoAMD<'_>>()
			),
			Err(CallError::MissingCommand("vkSetGpaDeviceClockModeAMD"))
		));
		assert!(matches!(
			fixture
				.device
				.set_gpa_device_clock_mode_amd(std::mem::zeroed::<*mut vk::GpaDeviceClockModeInfoAMD<'_>>()),
			Err(CallError::MissingCommand("vkSetGpaDeviceClockModeAMD"))
		));
	}
}

#[test]
fn set_gpa_device_clock_mode_amd_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *mut vk::GpaDeviceClockModeInfoAMD<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *mut vk::GpaDeviceClockModeInfoAMD<'_>,
					)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkSetGpaDeviceClockModeAMD = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkSetGpaDeviceClockModeAMD, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkSetGpaDeviceClockModeAMD", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::set_gpa_device_clock_mode_amd(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *mut vk::GpaDeviceClockModeInfoAMD<'_>
				),
				expected
			);
			assert_eq!(
				vk::Device::set_gpa_device_clock_mode_amd(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *mut vk::GpaDeviceClockModeInfoAMD<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_gpa_device_clock_info_amd_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, *mut vk::GpaDeviceGetClockInfoAMD<'_>) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_gpa_device_clock_info_amd;
	let _: Signature = vk::Device::get_gpa_device_clock_info_amd;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_gpa_device_clock_info_amd(
				&fixture.device,
				std::mem::zeroed::<*mut vk::GpaDeviceGetClockInfoAMD<'_>>()
			),
			Err(CallError::MissingCommand("vkGetGpaDeviceClockInfoAMD"))
		));
		assert!(matches!(
			fixture
				.device
				.get_gpa_device_clock_info_amd(std::mem::zeroed::<*mut vk::GpaDeviceGetClockInfoAMD<'_>>()),
			Err(CallError::MissingCommand("vkGetGpaDeviceClockInfoAMD"))
		));
	}
}

#[test]
fn get_gpa_device_clock_info_amd_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *mut vk::GpaDeviceGetClockInfoAMD<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *mut vk::GpaDeviceGetClockInfoAMD<'_>,
					)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetGpaDeviceClockInfoAMD = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkGetGpaDeviceClockInfoAMD, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkGetGpaDeviceClockInfoAMD", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_gpa_device_clock_info_amd(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *mut vk::GpaDeviceGetClockInfoAMD<'_>
				),
				expected
			);
			assert_eq!(
				vk::Device::get_gpa_device_clock_info_amd(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *mut vk::GpaDeviceGetClockInfoAMD<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_begin_gpa_session_amd_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, vk::CommandBuffer, vk::GpaSessionAMD) -> Result<vk::Result, CallError>;
	let _: Signature = vk::cmd_begin_gpa_session_amd;
	let _: Signature = vk::Device::cmd_begin_gpa_session_amd;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_begin_gpa_session_amd(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::GpaSessionAMD>()
			),
			Err(CallError::MissingCommand("vkCmdBeginGpaSessionAMD"))
		));
		assert!(matches!(
			fixture.device.cmd_begin_gpa_session_amd(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::GpaSessionAMD>()
			),
			Err(CallError::MissingCommand("vkCmdBeginGpaSessionAMD"))
		));
	}
}

#[test]
fn cmd_begin_gpa_session_amd_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::CommandBuffer, arg_1: vk::GpaSessionAMD) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == vk::GpaSessionAMD::from_raw(305398016_u64 as _)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdBeginGpaSessionAMD = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdBeginGpaSessionAMD, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdBeginGpaSessionAMD", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::cmd_begin_gpa_session_amd(
					&fixture.device,
					vk::CommandBuffer::from_raw(305397760_u64 as _),
					vk::GpaSessionAMD::from_raw(305398016_u64 as _)
				),
				expected
			);
			assert_eq!(
				vk::Device::cmd_begin_gpa_session_amd(
					&fixture.device,
					vk::CommandBuffer::from_raw(305397760_u64 as _),
					vk::GpaSessionAMD::from_raw(305398016_u64 as _)
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_end_gpa_session_amd_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, vk::CommandBuffer, vk::GpaSessionAMD) -> Result<vk::Result, CallError>;
	let _: Signature = vk::cmd_end_gpa_session_amd;
	let _: Signature = vk::Device::cmd_end_gpa_session_amd;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_end_gpa_session_amd(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::GpaSessionAMD>()
			),
			Err(CallError::MissingCommand("vkCmdEndGpaSessionAMD"))
		));
		assert!(matches!(
			fixture.device.cmd_end_gpa_session_amd(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::GpaSessionAMD>()
			),
			Err(CallError::MissingCommand("vkCmdEndGpaSessionAMD"))
		));
	}
}

#[test]
fn cmd_end_gpa_session_amd_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::CommandBuffer, arg_1: vk::GpaSessionAMD) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == vk::GpaSessionAMD::from_raw(305398016_u64 as _)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdEndGpaSessionAMD = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdEndGpaSessionAMD, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdEndGpaSessionAMD", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::cmd_end_gpa_session_amd(
					&fixture.device,
					vk::CommandBuffer::from_raw(305397760_u64 as _),
					vk::GpaSessionAMD::from_raw(305398016_u64 as _)
				),
				expected
			);
			assert_eq!(
				vk::Device::cmd_end_gpa_session_amd(
					&fixture.device,
					vk::CommandBuffer::from_raw(305397760_u64 as _),
					vk::GpaSessionAMD::from_raw(305398016_u64 as _)
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_begin_gpa_sample_amd_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		vk::GpaSessionAMD,
		*const vk::GpaSampleBeginInfoAMD<'_>,
		*mut u32,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::cmd_begin_gpa_sample_amd;
	let _: Signature = vk::Device::cmd_begin_gpa_sample_amd;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_begin_gpa_sample_amd(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::GpaSessionAMD>(),
				std::mem::zeroed::<*const vk::GpaSampleBeginInfoAMD<'_>>(),
				std::mem::zeroed::<*mut u32>()
			),
			Err(CallError::MissingCommand("vkCmdBeginGpaSampleAMD"))
		));
		assert!(matches!(
			fixture.device.cmd_begin_gpa_sample_amd(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::GpaSessionAMD>(),
				std::mem::zeroed::<*const vk::GpaSampleBeginInfoAMD<'_>>(),
				std::mem::zeroed::<*mut u32>()
			),
			Err(CallError::MissingCommand("vkCmdBeginGpaSampleAMD"))
		));
	}
}

#[test]
fn cmd_begin_gpa_sample_amd_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: vk::GpaSessionAMD,
		arg_2: *const vk::GpaSampleBeginInfoAMD<'_>,
		arg_3: *mut u32,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == vk::GpaSessionAMD::from_raw(305398016_u64 as _)
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *const vk::GpaSampleBeginInfoAMD<'_>,
					) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut u32,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdBeginGpaSampleAMD = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdBeginGpaSampleAMD, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdBeginGpaSampleAMD", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::cmd_begin_gpa_sample_amd(
					&fixture.device,
					vk::CommandBuffer::from_raw(305397760_u64 as _),
					vk::GpaSessionAMD::from_raw(305398016_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::GpaSampleBeginInfoAMD<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut u32
				),
				expected
			);
			assert_eq!(
				vk::Device::cmd_begin_gpa_sample_amd(
					&fixture.device,
					vk::CommandBuffer::from_raw(305397760_u64 as _),
					vk::GpaSessionAMD::from_raw(305398016_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::GpaSampleBeginInfoAMD<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut u32
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_end_gpa_sample_amd_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, vk::CommandBuffer, vk::GpaSessionAMD, u32) -> Result<(), CallError>;
	let _: Signature = vk::cmd_end_gpa_sample_amd;
	let _: Signature = vk::Device::cmd_end_gpa_sample_amd;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_end_gpa_sample_amd(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::GpaSessionAMD>(),
				std::mem::zeroed::<u32>()
			),
			Err(CallError::MissingCommand("vkCmdEndGpaSampleAMD"))
		));
		assert!(matches!(
			fixture.device.cmd_end_gpa_sample_amd(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::GpaSessionAMD>(),
				std::mem::zeroed::<u32>()
			),
			Err(CallError::MissingCommand("vkCmdEndGpaSampleAMD"))
		));
	}
}

#[test]
fn cmd_end_gpa_sample_amd_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::CommandBuffer, arg_1: vk::GpaSessionAMD, arg_2: u32) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == vk::GpaSessionAMD::from_raw(305398016_u64 as _)
					&& arg_2 == Default::default()),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdEndGpaSampleAMD = Some(mock);
		let erased = std::mem::transmute::<vk::PFN_vkCmdEndGpaSampleAMD, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdEndGpaSampleAMD", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_end_gpa_sample_amd(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::GpaSessionAMD::from_raw(305398016_u64 as _),
			Default::default(),
		)
		.unwrap();
		vk::Device::cmd_end_gpa_sample_amd(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::GpaSessionAMD::from_raw(305398016_u64 as _),
			Default::default(),
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_gpa_session_status_amd_signature_and_missing_command() {
	type Signature = unsafe fn(&vk::Device, vk::GpaSessionAMD) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_gpa_session_status_amd;
	let _: Signature = vk::Device::get_gpa_session_status_amd;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_gpa_session_status_amd(&fixture.device, std::mem::zeroed::<vk::GpaSessionAMD>()),
			Err(CallError::MissingCommand("vkGetGpaSessionStatusAMD"))
		));
		assert!(matches!(
			fixture
				.device
				.get_gpa_session_status_amd(std::mem::zeroed::<vk::GpaSessionAMD>()),
			Err(CallError::MissingCommand("vkGetGpaSessionStatusAMD"))
		));
	}
}

#[test]
fn get_gpa_session_status_amd_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::DeviceHandle, arg_1: vk::GpaSessionAMD) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::GpaSessionAMD::from_raw(305398016_u64 as _)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetGpaSessionStatusAMD = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkGetGpaSessionStatusAMD, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkGetGpaSessionStatusAMD", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_gpa_session_status_amd(
					&fixture.device,
					vk::GpaSessionAMD::from_raw(305398016_u64 as _)
				),
				expected
			);
			assert_eq!(
				vk::Device::get_gpa_session_status_amd(
					&fixture.device,
					vk::GpaSessionAMD::from_raw(305398016_u64 as _)
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_gpa_session_results_amd_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::GpaSessionAMD,
		u32,
		*mut usize,
		*mut std::ffi::c_void,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_gpa_session_results_amd;
	let _: Signature = vk::Device::get_gpa_session_results_amd;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_gpa_session_results_amd(
				&fixture.device,
				std::mem::zeroed::<vk::GpaSessionAMD>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*mut usize>(),
				std::mem::zeroed::<*mut std::ffi::c_void>()
			),
			Err(CallError::MissingCommand("vkGetGpaSessionResultsAMD"))
		));
		assert!(matches!(
			fixture.device.get_gpa_session_results_amd(
				std::mem::zeroed::<vk::GpaSessionAMD>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*mut usize>(),
				std::mem::zeroed::<*mut std::ffi::c_void>()
			),
			Err(CallError::MissingCommand("vkGetGpaSessionResultsAMD"))
		));
	}
}

#[test]
fn get_gpa_session_results_amd_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::GpaSessionAMD,
		arg_2: u32,
		arg_3: *mut usize,
		arg_4: *mut std::ffi::c_void,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::GpaSessionAMD::from_raw(305398016_u64 as _)
					&& arg_2 == Default::default()
					&& std::ptr::eq(
						arg_3,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut usize,
					) && std::ptr::eq(
					arg_4,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784),
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetGpaSessionResultsAMD = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkGetGpaSessionResultsAMD, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkGetGpaSessionResultsAMD", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_gpa_session_results_amd(
					&fixture.device,
					vk::GpaSessionAMD::from_raw(305398016_u64 as _),
					Default::default(),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut usize,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784)
				),
				expected
			);
			assert_eq!(
				vk::Device::get_gpa_session_results_amd(
					&fixture.device,
					vk::GpaSessionAMD::from_raw(305398016_u64 as _),
					Default::default(),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut usize,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784)
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn reset_gpa_session_amd_signature_and_missing_command() {
	type Signature = unsafe fn(&vk::Device, vk::GpaSessionAMD) -> Result<vk::Result, CallError>;
	let _: Signature = vk::reset_gpa_session_amd;
	let _: Signature = vk::Device::reset_gpa_session_amd;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::reset_gpa_session_amd(&fixture.device, std::mem::zeroed::<vk::GpaSessionAMD>()),
			Err(CallError::MissingCommand("vkResetGpaSessionAMD"))
		));
		assert!(matches!(
			fixture
				.device
				.reset_gpa_session_amd(std::mem::zeroed::<vk::GpaSessionAMD>()),
			Err(CallError::MissingCommand("vkResetGpaSessionAMD"))
		));
	}
}

#[test]
fn reset_gpa_session_amd_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::DeviceHandle, arg_1: vk::GpaSessionAMD) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::GpaSessionAMD::from_raw(305398016_u64 as _)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkResetGpaSessionAMD = Some(mock);
		let erased = std::mem::transmute::<vk::PFN_vkResetGpaSessionAMD, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkResetGpaSessionAMD", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::reset_gpa_session_amd(
					&fixture.device,
					vk::GpaSessionAMD::from_raw(305398016_u64 as _)
				),
				expected
			);
			assert_eq!(
				vk::Device::reset_gpa_session_amd(
					&fixture.device,
					vk::GpaSessionAMD::from_raw(305398016_u64 as _)
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_copy_gpa_session_results_amd_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, vk::CommandBuffer, vk::GpaSessionAMD) -> Result<(), CallError>;
	let _: Signature = vk::cmd_copy_gpa_session_results_amd;
	let _: Signature = vk::Device::cmd_copy_gpa_session_results_amd;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_copy_gpa_session_results_amd(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::GpaSessionAMD>()
			),
			Err(CallError::MissingCommand("vkCmdCopyGpaSessionResultsAMD"))
		));
		assert!(matches!(
			fixture.device.cmd_copy_gpa_session_results_amd(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::GpaSessionAMD>()
			),
			Err(CallError::MissingCommand("vkCmdCopyGpaSessionResultsAMD"))
		));
	}
}

#[test]
fn cmd_copy_gpa_session_results_amd_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::CommandBuffer, arg_1: vk::GpaSessionAMD) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == vk::GpaSessionAMD::from_raw(305398016_u64 as _)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdCopyGpaSessionResultsAMD = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdCopyGpaSessionResultsAMD, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdCopyGpaSessionResultsAMD", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_copy_gpa_session_results_amd(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::GpaSessionAMD::from_raw(305398016_u64 as _),
		)
		.unwrap();
		vk::Device::cmd_copy_gpa_session_results_amd(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::GpaSessionAMD::from_raw(305398016_u64 as _),
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_bind_descriptor_sets2_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		*const vk::BindDescriptorSetsInfo<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_bind_descriptor_sets2;
	let _: Signature = vk::Device::cmd_bind_descriptor_sets2;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_bind_descriptor_sets2(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::BindDescriptorSetsInfo<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdBindDescriptorSets2"))
		));
		assert!(matches!(
			fixture.device.cmd_bind_descriptor_sets2(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::BindDescriptorSetsInfo<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdBindDescriptorSets2"))
		));
	}
}

#[test]
fn cmd_bind_descriptor_sets2_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: *const vk::BindDescriptorSetsInfo<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::BindDescriptorSetsInfo<'_>,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdBindDescriptorSets2 = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdBindDescriptorSets2, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdBindDescriptorSets2", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_bind_descriptor_sets2(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::BindDescriptorSetsInfo<'_>,
		)
		.unwrap();
		vk::Device::cmd_bind_descriptor_sets2(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::BindDescriptorSetsInfo<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_bind_descriptor_sets2_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		*const vk::BindDescriptorSetsInfo<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_bind_descriptor_sets2_khr;
	let _: Signature = vk::Device::cmd_bind_descriptor_sets2_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_bind_descriptor_sets2_khr(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::BindDescriptorSetsInfo<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdBindDescriptorSets2KHR"))
		));
		assert!(matches!(
			fixture.device.cmd_bind_descriptor_sets2_khr(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::BindDescriptorSetsInfo<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdBindDescriptorSets2KHR"))
		));
	}
}

#[test]
fn cmd_bind_descriptor_sets2_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: *const vk::BindDescriptorSetsInfo<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::BindDescriptorSetsInfo<'_>,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdBindDescriptorSets2KHR = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdBindDescriptorSets2KHR, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdBindDescriptorSets2KHR", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_bind_descriptor_sets2_khr(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::BindDescriptorSetsInfo<'_>,
		)
		.unwrap();
		vk::Device::cmd_bind_descriptor_sets2_khr(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::BindDescriptorSetsInfo<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_push_constants2_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		*const vk::PushConstantsInfo<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_push_constants2;
	let _: Signature = vk::Device::cmd_push_constants2;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_push_constants2(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::PushConstantsInfo<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdPushConstants2"))
		));
		assert!(matches!(
			fixture.device.cmd_push_constants2(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::PushConstantsInfo<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdPushConstants2"))
		));
	}
}

#[test]
fn cmd_push_constants2_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: *const vk::PushConstantsInfo<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::PushConstantsInfo<'_>,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdPushConstants2 = Some(mock);
		let erased = std::mem::transmute::<vk::PFN_vkCmdPushConstants2, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdPushConstants2", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_push_constants2(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::PushConstantsInfo<'_>,
		)
		.unwrap();
		vk::Device::cmd_push_constants2(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::PushConstantsInfo<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_push_constants2_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		*const vk::PushConstantsInfo<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_push_constants2_khr;
	let _: Signature = vk::Device::cmd_push_constants2_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_push_constants2_khr(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::PushConstantsInfo<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdPushConstants2KHR"))
		));
		assert!(matches!(
			fixture.device.cmd_push_constants2_khr(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::PushConstantsInfo<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdPushConstants2KHR"))
		));
	}
}

#[test]
fn cmd_push_constants2_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: *const vk::PushConstantsInfo<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::PushConstantsInfo<'_>,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdPushConstants2KHR = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdPushConstants2KHR, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdPushConstants2KHR", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_push_constants2_khr(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::PushConstantsInfo<'_>,
		)
		.unwrap();
		vk::Device::cmd_push_constants2_khr(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::PushConstantsInfo<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_push_descriptor_set2_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		*const vk::PushDescriptorSetInfo<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_push_descriptor_set2;
	let _: Signature = vk::Device::cmd_push_descriptor_set2;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_push_descriptor_set2(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::PushDescriptorSetInfo<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdPushDescriptorSet2"))
		));
		assert!(matches!(
			fixture.device.cmd_push_descriptor_set2(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::PushDescriptorSetInfo<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdPushDescriptorSet2"))
		));
	}
}

#[test]
fn cmd_push_descriptor_set2_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: *const vk::PushDescriptorSetInfo<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::PushDescriptorSetInfo<'_>,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdPushDescriptorSet2 = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdPushDescriptorSet2, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdPushDescriptorSet2", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_push_descriptor_set2(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::PushDescriptorSetInfo<'_>,
		)
		.unwrap();
		vk::Device::cmd_push_descriptor_set2(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::PushDescriptorSetInfo<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_push_descriptor_set2_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		*const vk::PushDescriptorSetInfo<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_push_descriptor_set2_khr;
	let _: Signature = vk::Device::cmd_push_descriptor_set2_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_push_descriptor_set2_khr(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::PushDescriptorSetInfo<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdPushDescriptorSet2KHR"))
		));
		assert!(matches!(
			fixture.device.cmd_push_descriptor_set2_khr(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::PushDescriptorSetInfo<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdPushDescriptorSet2KHR"))
		));
	}
}

#[test]
fn cmd_push_descriptor_set2_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: *const vk::PushDescriptorSetInfo<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::PushDescriptorSetInfo<'_>,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdPushDescriptorSet2KHR = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdPushDescriptorSet2KHR, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdPushDescriptorSet2KHR", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_push_descriptor_set2_khr(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::PushDescriptorSetInfo<'_>,
		)
		.unwrap();
		vk::Device::cmd_push_descriptor_set2_khr(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::PushDescriptorSetInfo<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_push_descriptor_set_with_template2_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		*const vk::PushDescriptorSetWithTemplateInfo<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_push_descriptor_set_with_template2;
	let _: Signature = vk::Device::cmd_push_descriptor_set_with_template2;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_push_descriptor_set_with_template2(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::PushDescriptorSetWithTemplateInfo<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkCmdPushDescriptorSetWithTemplate2"
			))
		));
		assert!(matches!(
			fixture.device.cmd_push_descriptor_set_with_template2(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::PushDescriptorSetWithTemplateInfo<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkCmdPushDescriptorSetWithTemplate2"
			))
		));
	}
}

#[test]
fn cmd_push_descriptor_set_with_template2_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: *const vk::PushDescriptorSetWithTemplateInfo<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::PushDescriptorSetWithTemplateInfo<'_>,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdPushDescriptorSetWithTemplate2 = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkCmdPushDescriptorSetWithTemplate2,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdPushDescriptorSetWithTemplate2", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_push_descriptor_set_with_template2(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::PushDescriptorSetWithTemplateInfo<'_>,
		)
		.unwrap();
		vk::Device::cmd_push_descriptor_set_with_template2(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::PushDescriptorSetWithTemplateInfo<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_push_descriptor_set_with_template2_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		*const vk::PushDescriptorSetWithTemplateInfo<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_push_descriptor_set_with_template2_khr;
	let _: Signature = vk::Device::cmd_push_descriptor_set_with_template2_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_push_descriptor_set_with_template2_khr(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::PushDescriptorSetWithTemplateInfo<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkCmdPushDescriptorSetWithTemplate2KHR"
			))
		));
		assert!(matches!(
			fixture.device.cmd_push_descriptor_set_with_template2_khr(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::PushDescriptorSetWithTemplateInfo<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkCmdPushDescriptorSetWithTemplate2KHR"
			))
		));
	}
}

#[test]
fn cmd_push_descriptor_set_with_template2_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: *const vk::PushDescriptorSetWithTemplateInfo<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::PushDescriptorSetWithTemplateInfo<'_>,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdPushDescriptorSetWithTemplate2KHR = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkCmdPushDescriptorSetWithTemplate2KHR,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdPushDescriptorSetWithTemplate2KHR", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_push_descriptor_set_with_template2_khr(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::PushDescriptorSetWithTemplateInfo<'_>,
		)
		.unwrap();
		vk::Device::cmd_push_descriptor_set_with_template2_khr(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::PushDescriptorSetWithTemplateInfo<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_set_descriptor_buffer_offsets2_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		*const vk::SetDescriptorBufferOffsetsInfoEXT<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_descriptor_buffer_offsets2_ext;
	let _: Signature = vk::Device::cmd_set_descriptor_buffer_offsets2_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_descriptor_buffer_offsets2_ext(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::SetDescriptorBufferOffsetsInfoEXT<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkCmdSetDescriptorBufferOffsets2EXT"
			))
		));
		assert!(matches!(
			fixture.device.cmd_set_descriptor_buffer_offsets2_ext(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::SetDescriptorBufferOffsetsInfoEXT<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkCmdSetDescriptorBufferOffsets2EXT"
			))
		));
	}
}

#[test]
fn cmd_set_descriptor_buffer_offsets2_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: *const vk::SetDescriptorBufferOffsetsInfoEXT<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::SetDescriptorBufferOffsetsInfoEXT<'_>,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdSetDescriptorBufferOffsets2EXT = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkCmdSetDescriptorBufferOffsets2EXT,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdSetDescriptorBufferOffsets2EXT", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_set_descriptor_buffer_offsets2_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::SetDescriptorBufferOffsetsInfoEXT<'_>,
		)
		.unwrap();
		vk::Device::cmd_set_descriptor_buffer_offsets2_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::SetDescriptorBufferOffsetsInfoEXT<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_bind_descriptor_buffer_embedded_samplers2_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		*const vk::BindDescriptorBufferEmbeddedSamplersInfoEXT<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_bind_descriptor_buffer_embedded_samplers2_ext;
	let _: Signature = vk::Device::cmd_bind_descriptor_buffer_embedded_samplers2_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_bind_descriptor_buffer_embedded_samplers2_ext(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::BindDescriptorBufferEmbeddedSamplersInfoEXT<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkCmdBindDescriptorBufferEmbeddedSamplers2EXT"
			))
		));
		assert!(matches!(
			fixture
				.device
				.cmd_bind_descriptor_buffer_embedded_samplers2_ext(
					std::mem::zeroed::<vk::CommandBuffer>(),
					std::mem::zeroed::<*const vk::BindDescriptorBufferEmbeddedSamplersInfoEXT<'_>>()
				),
			Err(CallError::MissingCommand(
				"vkCmdBindDescriptorBufferEmbeddedSamplers2EXT"
			))
		));
	}
}

#[test]
fn cmd_bind_descriptor_buffer_embedded_samplers2_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: *const vk::BindDescriptorBufferEmbeddedSamplersInfoEXT<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::BindDescriptorBufferEmbeddedSamplersInfoEXT<'_>,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture =
			Fixture::new_with_command(c"vkCmdBindDescriptorBufferEmbeddedSamplers2EXT", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_bind_descriptor_buffer_embedded_samplers2_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::BindDescriptorBufferEmbeddedSamplersInfoEXT<'_>,
		)
		.unwrap();
		vk::Device::cmd_bind_descriptor_buffer_embedded_samplers2_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::BindDescriptorBufferEmbeddedSamplersInfoEXT<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn set_latency_sleep_mode_nv_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::SwapchainKHR,
		*const vk::LatencySleepModeInfoNV<'_>,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::set_latency_sleep_mode_nv;
	let _: Signature = vk::Device::set_latency_sleep_mode_nv;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::set_latency_sleep_mode_nv(
				&fixture.device,
				std::mem::zeroed::<vk::SwapchainKHR>(),
				std::mem::zeroed::<*const vk::LatencySleepModeInfoNV<'_>>()
			),
			Err(CallError::MissingCommand("vkSetLatencySleepModeNV"))
		));
		assert!(matches!(
			fixture.device.set_latency_sleep_mode_nv(
				std::mem::zeroed::<vk::SwapchainKHR>(),
				std::mem::zeroed::<*const vk::LatencySleepModeInfoNV<'_>>()
			),
			Err(CallError::MissingCommand("vkSetLatencySleepModeNV"))
		));
	}
}

#[test]
fn set_latency_sleep_mode_nv_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::SwapchainKHR,
		arg_2: *const vk::LatencySleepModeInfoNV<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::SwapchainKHR::from_raw(305398016_u64 as _)
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *const vk::LatencySleepModeInfoNV<'_>,
					)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkSetLatencySleepModeNV = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkSetLatencySleepModeNV, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkSetLatencySleepModeNV", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::set_latency_sleep_mode_nv(
					&fixture.device,
					vk::SwapchainKHR::from_raw(305398016_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::LatencySleepModeInfoNV<'_>
				),
				expected
			);
			assert_eq!(
				vk::Device::set_latency_sleep_mode_nv(
					&fixture.device,
					vk::SwapchainKHR::from_raw(305398016_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::LatencySleepModeInfoNV<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn latency_sleep_nv_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::SwapchainKHR,
		*const vk::LatencySleepInfoNV<'_>,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::latency_sleep_nv;
	let _: Signature = vk::Device::latency_sleep_nv;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::latency_sleep_nv(
				&fixture.device,
				std::mem::zeroed::<vk::SwapchainKHR>(),
				std::mem::zeroed::<*const vk::LatencySleepInfoNV<'_>>()
			),
			Err(CallError::MissingCommand("vkLatencySleepNV"))
		));
		assert!(matches!(
			fixture.device.latency_sleep_nv(
				std::mem::zeroed::<vk::SwapchainKHR>(),
				std::mem::zeroed::<*const vk::LatencySleepInfoNV<'_>>()
			),
			Err(CallError::MissingCommand("vkLatencySleepNV"))
		));
	}
}

#[test]
fn latency_sleep_nv_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::SwapchainKHR,
		arg_2: *const vk::LatencySleepInfoNV<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::SwapchainKHR::from_raw(305398016_u64 as _)
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *const vk::LatencySleepInfoNV<'_>,
					)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkLatencySleepNV = Some(mock);
		let erased = std::mem::transmute::<vk::PFN_vkLatencySleepNV, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkLatencySleepNV", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::latency_sleep_nv(
					&fixture.device,
					vk::SwapchainKHR::from_raw(305398016_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::LatencySleepInfoNV<'_>
				),
				expected
			);
			assert_eq!(
				vk::Device::latency_sleep_nv(
					&fixture.device,
					vk::SwapchainKHR::from_raw(305398016_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::LatencySleepInfoNV<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn set_latency_marker_nv_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::SwapchainKHR,
		*const vk::SetLatencyMarkerInfoNV<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::set_latency_marker_nv;
	let _: Signature = vk::Device::set_latency_marker_nv;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::set_latency_marker_nv(
				&fixture.device,
				std::mem::zeroed::<vk::SwapchainKHR>(),
				std::mem::zeroed::<*const vk::SetLatencyMarkerInfoNV<'_>>()
			),
			Err(CallError::MissingCommand("vkSetLatencyMarkerNV"))
		));
		assert!(matches!(
			fixture.device.set_latency_marker_nv(
				std::mem::zeroed::<vk::SwapchainKHR>(),
				std::mem::zeroed::<*const vk::SetLatencyMarkerInfoNV<'_>>()
			),
			Err(CallError::MissingCommand("vkSetLatencyMarkerNV"))
		));
	}
}

#[test]
fn set_latency_marker_nv_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::SwapchainKHR,
		arg_2: *const vk::SetLatencyMarkerInfoNV<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::SwapchainKHR::from_raw(305398016_u64 as _)
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *const vk::SetLatencyMarkerInfoNV<'_>,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkSetLatencyMarkerNV = Some(mock);
		let erased = std::mem::transmute::<vk::PFN_vkSetLatencyMarkerNV, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkSetLatencyMarkerNV", erased);
		let resolutions = Fixture::query_count();
		vk::set_latency_marker_nv(
			&fixture.device,
			vk::SwapchainKHR::from_raw(305398016_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::SetLatencyMarkerInfoNV<'_>,
		)
		.unwrap();
		vk::Device::set_latency_marker_nv(
			&fixture.device,
			vk::SwapchainKHR::from_raw(305398016_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::SetLatencyMarkerInfoNV<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_latency_timings_nv_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::SwapchainKHR,
		*mut vk::GetLatencyMarkerInfoNV<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::get_latency_timings_nv;
	let _: Signature = vk::Device::get_latency_timings_nv;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_latency_timings_nv(
				&fixture.device,
				std::mem::zeroed::<vk::SwapchainKHR>(),
				std::mem::zeroed::<*mut vk::GetLatencyMarkerInfoNV<'_>>()
			),
			Err(CallError::MissingCommand("vkGetLatencyTimingsNV"))
		));
		assert!(matches!(
			fixture.device.get_latency_timings_nv(
				std::mem::zeroed::<vk::SwapchainKHR>(),
				std::mem::zeroed::<*mut vk::GetLatencyMarkerInfoNV<'_>>()
			),
			Err(CallError::MissingCommand("vkGetLatencyTimingsNV"))
		));
	}
}

#[test]
fn get_latency_timings_nv_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::SwapchainKHR,
		arg_2: *mut vk::GetLatencyMarkerInfoNV<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::SwapchainKHR::from_raw(305398016_u64 as _)
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *mut vk::GetLatencyMarkerInfoNV<'_>,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetLatencyTimingsNV = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkGetLatencyTimingsNV, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkGetLatencyTimingsNV", erased);
		let resolutions = Fixture::query_count();
		vk::get_latency_timings_nv(
			&fixture.device,
			vk::SwapchainKHR::from_raw(305398016_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *mut vk::GetLatencyMarkerInfoNV<'_>,
		)
		.unwrap();
		vk::Device::get_latency_timings_nv(
			&fixture.device,
			vk::SwapchainKHR::from_raw(305398016_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *mut vk::GetLatencyMarkerInfoNV<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn queue_notify_out_of_band_nv_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::Queue,
		*const vk::OutOfBandQueueTypeInfoNV<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::queue_notify_out_of_band_nv;
	let _: Signature = vk::Device::queue_notify_out_of_band_nv;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::queue_notify_out_of_band_nv(
				&fixture.device,
				std::mem::zeroed::<vk::Queue>(),
				std::mem::zeroed::<*const vk::OutOfBandQueueTypeInfoNV<'_>>()
			),
			Err(CallError::MissingCommand("vkQueueNotifyOutOfBandNV"))
		));
		assert!(matches!(
			fixture.device.queue_notify_out_of_band_nv(
				std::mem::zeroed::<vk::Queue>(),
				std::mem::zeroed::<*const vk::OutOfBandQueueTypeInfoNV<'_>>()
			),
			Err(CallError::MissingCommand("vkQueueNotifyOutOfBandNV"))
		));
	}
}

#[test]
fn queue_notify_out_of_band_nv_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::Queue, arg_1: *const vk::OutOfBandQueueTypeInfoNV<'_>) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::Queue::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::OutOfBandQueueTypeInfoNV<'_>,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkQueueNotifyOutOfBandNV = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkQueueNotifyOutOfBandNV, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkQueueNotifyOutOfBandNV", erased);
		let resolutions = Fixture::query_count();
		vk::queue_notify_out_of_band_nv(
			&fixture.device,
			vk::Queue::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::OutOfBandQueueTypeInfoNV<'_>,
		)
		.unwrap();
		vk::Device::queue_notify_out_of_band_nv(
			&fixture.device,
			vk::Queue::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::OutOfBandQueueTypeInfoNV<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn set_latency_sleep_mode_legacy_nv_signature_and_missing_command() {
	type Signature = unsafe fn(&vk::Device, vk::Bool32, vk::Bool32, u32) -> Result<(), CallError>;
	let _: Signature = vk::set_latency_sleep_mode_legacy_nv;
	let _: Signature = vk::Device::set_latency_sleep_mode_legacy_nv;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::set_latency_sleep_mode_legacy_nv(
				&fixture.device,
				std::mem::zeroed::<vk::Bool32>(),
				std::mem::zeroed::<vk::Bool32>(),
				std::mem::zeroed::<u32>()
			),
			Err(CallError::MissingCommand("vkSetLatencySleepModeLegacyNV"))
		));
		assert!(matches!(
			fixture.device.set_latency_sleep_mode_legacy_nv(
				std::mem::zeroed::<vk::Bool32>(),
				std::mem::zeroed::<vk::Bool32>(),
				std::mem::zeroed::<u32>()
			),
			Err(CallError::MissingCommand("vkSetLatencySleepModeLegacyNV"))
		));
	}
}

#[test]
fn set_latency_sleep_mode_legacy_nv_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::Bool32,
		arg_2: vk::Bool32,
		arg_3: u32,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == 305398016_u64 as vk::Bool32
					&& arg_2 == 305398272_u64 as vk::Bool32
					&& arg_3 == Default::default()),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkSetLatencySleepModeLegacyNV = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkSetLatencySleepModeLegacyNV, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkSetLatencySleepModeLegacyNV", erased);
		let resolutions = Fixture::query_count();
		vk::set_latency_sleep_mode_legacy_nv(
			&fixture.device,
			305398016_u64 as vk::Bool32,
			305398272_u64 as vk::Bool32,
			Default::default(),
		)
		.unwrap();
		vk::Device::set_latency_sleep_mode_legacy_nv(
			&fixture.device,
			305398016_u64 as vk::Bool32,
			305398272_u64 as vk::Bool32,
			Default::default(),
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn latency_sleep_legacy_nv_signature_and_missing_command() {
	type Signature = unsafe fn(&vk::Device, vk::Semaphore, u64) -> Result<(), CallError>;
	let _: Signature = vk::latency_sleep_legacy_nv;
	let _: Signature = vk::Device::latency_sleep_legacy_nv;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::latency_sleep_legacy_nv(
				&fixture.device,
				std::mem::zeroed::<vk::Semaphore>(),
				std::mem::zeroed::<u64>()
			),
			Err(CallError::MissingCommand("vkLatencySleepLegacyNV"))
		));
		assert!(matches!(
			fixture.device.latency_sleep_legacy_nv(
				std::mem::zeroed::<vk::Semaphore>(),
				std::mem::zeroed::<u64>()
			),
			Err(CallError::MissingCommand("vkLatencySleepLegacyNV"))
		));
	}
}

#[test]
fn latency_sleep_legacy_nv_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::DeviceHandle, arg_1: vk::Semaphore, arg_2: u64) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::Semaphore::from_raw(305398016_u64 as _)
					&& arg_2 == Default::default()),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkLatencySleepLegacyNV = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkLatencySleepLegacyNV, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkLatencySleepLegacyNV", erased);
		let resolutions = Fixture::query_count();
		vk::latency_sleep_legacy_nv(
			&fixture.device,
			vk::Semaphore::from_raw(305398016_u64 as _),
			Default::default(),
		)
		.unwrap();
		vk::Device::latency_sleep_legacy_nv(
			&fixture.device,
			vk::Semaphore::from_raw(305398016_u64 as _),
			Default::default(),
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn set_latency_marker_legacy_nv_signature_and_missing_command() {
	type Signature = unsafe fn(&vk::Device, u64, u32) -> Result<(), CallError>;
	let _: Signature = vk::set_latency_marker_legacy_nv;
	let _: Signature = vk::Device::set_latency_marker_legacy_nv;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::set_latency_marker_legacy_nv(
				&fixture.device,
				std::mem::zeroed::<u64>(),
				std::mem::zeroed::<u32>()
			),
			Err(CallError::MissingCommand("vkSetLatencyMarkerLegacyNV"))
		));
		assert!(matches!(
			fixture
				.device
				.set_latency_marker_legacy_nv(std::mem::zeroed::<u64>(), std::mem::zeroed::<u32>()),
			Err(CallError::MissingCommand("vkSetLatencyMarkerLegacyNV"))
		));
	}
}

#[test]
fn set_latency_marker_legacy_nv_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::DeviceHandle, arg_1: u64, arg_2: u32) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == Default::default()
					&& arg_2 == Default::default()),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkSetLatencyMarkerLegacyNV = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkSetLatencyMarkerLegacyNV, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkSetLatencyMarkerLegacyNV", erased);
		let resolutions = Fixture::query_count();
		vk::set_latency_marker_legacy_nv(&fixture.device, Default::default(), Default::default())
			.unwrap();
		vk::Device::set_latency_marker_legacy_nv(
			&fixture.device,
			Default::default(),
			Default::default(),
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_latency_timings_legacy_nv_signature_and_missing_command() {
	type Signature = unsafe fn(&vk::Device, *mut std::ffi::c_void) -> Result<(), CallError>;
	let _: Signature = vk::get_latency_timings_legacy_nv;
	let _: Signature = vk::Device::get_latency_timings_legacy_nv;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_latency_timings_legacy_nv(
				&fixture.device,
				std::mem::zeroed::<*mut std::ffi::c_void>()
			),
			Err(CallError::MissingCommand("vkGetLatencyTimingsLegacyNV"))
		));
		assert!(matches!(
			fixture
				.device
				.get_latency_timings_legacy_nv(std::mem::zeroed::<*mut std::ffi::c_void>()),
			Err(CallError::MissingCommand("vkGetLatencyTimingsLegacyNV"))
		));
	}
}

#[test]
fn get_latency_timings_legacy_nv_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::DeviceHandle, arg_1: *mut std::ffi::c_void) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016),
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetLatencyTimingsLegacyNV = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkGetLatencyTimingsLegacyNV, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkGetLatencyTimingsLegacyNV", erased);
		let resolutions = Fixture::query_count();
		vk::get_latency_timings_legacy_nv(
			&fixture.device,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016),
		)
		.unwrap();
		vk::Device::get_latency_timings_legacy_nv(
			&fixture.device,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016),
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn queue_notify_out_of_band_legacy_nv_signature_and_missing_command() {
	type Signature = unsafe fn(&vk::Device, vk::Queue, u32) -> Result<(), CallError>;
	let _: Signature = vk::queue_notify_out_of_band_legacy_nv;
	let _: Signature = vk::Device::queue_notify_out_of_band_legacy_nv;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::queue_notify_out_of_band_legacy_nv(
				&fixture.device,
				std::mem::zeroed::<vk::Queue>(),
				std::mem::zeroed::<u32>()
			),
			Err(CallError::MissingCommand("vkQueueNotifyOutOfBandLegacyNV"))
		));
		assert!(matches!(
			fixture.device.queue_notify_out_of_band_legacy_nv(
				std::mem::zeroed::<vk::Queue>(),
				std::mem::zeroed::<u32>()
			),
			Err(CallError::MissingCommand("vkQueueNotifyOutOfBandLegacyNV"))
		));
	}
}

#[test]
fn queue_notify_out_of_band_legacy_nv_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::Queue, arg_1: u32) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::Queue::from_raw(305397760_u64 as _) && arg_1 == Default::default()),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkQueueNotifyOutOfBandLegacyNV = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkQueueNotifyOutOfBandLegacyNV, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkQueueNotifyOutOfBandLegacyNV", erased);
		let resolutions = Fixture::query_count();
		vk::queue_notify_out_of_band_legacy_nv(
			&fixture.device,
			vk::Queue::from_raw(305397760_u64 as _),
			Default::default(),
		)
		.unwrap();
		vk::Device::queue_notify_out_of_band_legacy_nv(
			&fixture.device,
			vk::Queue::from_raw(305397760_u64 as _),
			Default::default(),
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_sleep_status_legacy_nv_signature_and_missing_command() {
	type Signature = unsafe fn(&vk::Device, *mut vk::Bool32) -> Result<(), CallError>;
	let _: Signature = vk::get_sleep_status_legacy_nv;
	let _: Signature = vk::Device::get_sleep_status_legacy_nv;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_sleep_status_legacy_nv(&fixture.device, std::mem::zeroed::<*mut vk::Bool32>()),
			Err(CallError::MissingCommand("vkGetSleepStatusLegacyNV"))
		));
		assert!(matches!(
			fixture
				.device
				.get_sleep_status_legacy_nv(std::mem::zeroed::<*mut vk::Bool32>()),
			Err(CallError::MissingCommand("vkGetSleepStatusLegacyNV"))
		));
	}
}

#[test]
fn get_sleep_status_legacy_nv_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::DeviceHandle, arg_1: *mut vk::Bool32) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016) as *mut vk::Bool32,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetSleepStatusLegacyNV = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkGetSleepStatusLegacyNV, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkGetSleepStatusLegacyNV", erased);
		let resolutions = Fixture::query_count();
		vk::get_sleep_status_legacy_nv(
			&fixture.device,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016) as *mut vk::Bool32,
		)
		.unwrap();
		vk::Device::get_sleep_status_legacy_nv(
			&fixture.device,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016) as *mut vk::Bool32,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn shutdown_latency_device_legacy_nv_signature_and_missing_command() {
	type Signature = unsafe fn(&vk::Device) -> Result<(), CallError>;
	let _: Signature = vk::shutdown_latency_device_legacy_nv;
	let _: Signature = vk::Device::shutdown_latency_device_legacy_nv;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::shutdown_latency_device_legacy_nv(&fixture.device,),
			Err(CallError::MissingCommand("vkShutdownLatencyDeviceLegacyNV"))
		));
		assert!(matches!(
			fixture.device.shutdown_latency_device_legacy_nv(),
			Err(CallError::MissingCommand("vkShutdownLatencyDeviceLegacyNV"))
		));
	}
}

#[test]
fn shutdown_latency_device_legacy_nv_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::DeviceHandle) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(MATCHED.get() && (arg_0 == vk::DeviceHandle::from_raw(0x2000)));
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkShutdownLatencyDeviceLegacyNV = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkShutdownLatencyDeviceLegacyNV, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkShutdownLatencyDeviceLegacyNV", erased);
		let resolutions = Fixture::query_count();
		vk::shutdown_latency_device_legacy_nv(&fixture.device).unwrap();
		vk::Device::shutdown_latency_device_legacy_nv(&fixture.device).unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_set_rendering_attachment_locations_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		*const vk::RenderingAttachmentLocationInfo<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_rendering_attachment_locations;
	let _: Signature = vk::Device::cmd_set_rendering_attachment_locations;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_rendering_attachment_locations(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::RenderingAttachmentLocationInfo<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkCmdSetRenderingAttachmentLocations"
			))
		));
		assert!(matches!(
			fixture.device.cmd_set_rendering_attachment_locations(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::RenderingAttachmentLocationInfo<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkCmdSetRenderingAttachmentLocations"
			))
		));
	}
}

#[test]
fn cmd_set_rendering_attachment_locations_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: *const vk::RenderingAttachmentLocationInfo<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::RenderingAttachmentLocationInfo<'_>,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdSetRenderingAttachmentLocations = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkCmdSetRenderingAttachmentLocations,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdSetRenderingAttachmentLocations", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_set_rendering_attachment_locations(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::RenderingAttachmentLocationInfo<'_>,
		)
		.unwrap();
		vk::Device::cmd_set_rendering_attachment_locations(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::RenderingAttachmentLocationInfo<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_set_rendering_attachment_locations_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		*const vk::RenderingAttachmentLocationInfo<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_rendering_attachment_locations_khr;
	let _: Signature = vk::Device::cmd_set_rendering_attachment_locations_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_rendering_attachment_locations_khr(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::RenderingAttachmentLocationInfo<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkCmdSetRenderingAttachmentLocationsKHR"
			))
		));
		assert!(matches!(
			fixture.device.cmd_set_rendering_attachment_locations_khr(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::RenderingAttachmentLocationInfo<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkCmdSetRenderingAttachmentLocationsKHR"
			))
		));
	}
}

#[test]
fn cmd_set_rendering_attachment_locations_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: *const vk::RenderingAttachmentLocationInfo<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::RenderingAttachmentLocationInfo<'_>,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdSetRenderingAttachmentLocationsKHR = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkCmdSetRenderingAttachmentLocationsKHR,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdSetRenderingAttachmentLocationsKHR", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_set_rendering_attachment_locations_khr(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::RenderingAttachmentLocationInfo<'_>,
		)
		.unwrap();
		vk::Device::cmd_set_rendering_attachment_locations_khr(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::RenderingAttachmentLocationInfo<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_set_rendering_input_attachment_indices_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		*const vk::RenderingInputAttachmentIndexInfo<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_rendering_input_attachment_indices;
	let _: Signature = vk::Device::cmd_set_rendering_input_attachment_indices;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_rendering_input_attachment_indices(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::RenderingInputAttachmentIndexInfo<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkCmdSetRenderingInputAttachmentIndices"
			))
		));
		assert!(matches!(
			fixture.device.cmd_set_rendering_input_attachment_indices(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::RenderingInputAttachmentIndexInfo<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkCmdSetRenderingInputAttachmentIndices"
			))
		));
	}
}

#[test]
fn cmd_set_rendering_input_attachment_indices_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: *const vk::RenderingInputAttachmentIndexInfo<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::RenderingInputAttachmentIndexInfo<'_>,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdSetRenderingInputAttachmentIndices = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkCmdSetRenderingInputAttachmentIndices,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdSetRenderingInputAttachmentIndices", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_set_rendering_input_attachment_indices(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::RenderingInputAttachmentIndexInfo<'_>,
		)
		.unwrap();
		vk::Device::cmd_set_rendering_input_attachment_indices(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::RenderingInputAttachmentIndexInfo<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_set_rendering_input_attachment_indices_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		*const vk::RenderingInputAttachmentIndexInfo<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_rendering_input_attachment_indices_khr;
	let _: Signature = vk::Device::cmd_set_rendering_input_attachment_indices_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_rendering_input_attachment_indices_khr(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::RenderingInputAttachmentIndexInfo<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkCmdSetRenderingInputAttachmentIndicesKHR"
			))
		));
		assert!(matches!(
			fixture
				.device
				.cmd_set_rendering_input_attachment_indices_khr(
					std::mem::zeroed::<vk::CommandBuffer>(),
					std::mem::zeroed::<*const vk::RenderingInputAttachmentIndexInfo<'_>>()
				),
			Err(CallError::MissingCommand(
				"vkCmdSetRenderingInputAttachmentIndicesKHR"
			))
		));
	}
}

#[test]
fn cmd_set_rendering_input_attachment_indices_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: *const vk::RenderingInputAttachmentIndexInfo<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::RenderingInputAttachmentIndexInfo<'_>,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdSetRenderingInputAttachmentIndicesKHR = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkCmdSetRenderingInputAttachmentIndicesKHR,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdSetRenderingInputAttachmentIndicesKHR", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_set_rendering_input_attachment_indices_khr(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::RenderingInputAttachmentIndexInfo<'_>,
		)
		.unwrap();
		vk::Device::cmd_set_rendering_input_attachment_indices_khr(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::RenderingInputAttachmentIndexInfo<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_set_depth_clamp_range_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		vk::DepthClampModeEXT,
		*const vk::DepthClampRangeEXT,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_depth_clamp_range_ext;
	let _: Signature = vk::Device::cmd_set_depth_clamp_range_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_depth_clamp_range_ext(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::DepthClampModeEXT>(),
				std::mem::zeroed::<*const vk::DepthClampRangeEXT>()
			),
			Err(CallError::MissingCommand("vkCmdSetDepthClampRangeEXT"))
		));
		assert!(matches!(
			fixture.device.cmd_set_depth_clamp_range_ext(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::DepthClampModeEXT>(),
				std::mem::zeroed::<*const vk::DepthClampRangeEXT>()
			),
			Err(CallError::MissingCommand("vkCmdSetDepthClampRangeEXT"))
		));
	}
}

#[test]
fn cmd_set_depth_clamp_range_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: vk::DepthClampModeEXT,
		arg_2: *const vk::DepthClampRangeEXT,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == vk::DepthClampModeEXT::from_raw(305398016_u64 as _)
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *const vk::DepthClampRangeEXT,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdSetDepthClampRangeEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdSetDepthClampRangeEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdSetDepthClampRangeEXT", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_set_depth_clamp_range_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::DepthClampModeEXT::from_raw(305398016_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::DepthClampRangeEXT,
		)
		.unwrap();
		vk::Device::cmd_set_depth_clamp_range_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::DepthClampModeEXT::from_raw(305398016_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::DepthClampRangeEXT,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_physical_device_cooperative_matrix_flexible_dimensions_properties_nv_signature_and_missing_command()
 {
	type Signature = unsafe fn(
		&vk::Instance,
		vk::PhysicalDevice,
		*mut u32,
		*mut vk::CooperativeMatrixFlexibleDimensionsPropertiesNV<'_>,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_physical_device_cooperative_matrix_flexible_dimensions_properties_nv;
	let _: Signature =
		vk::Instance::get_physical_device_cooperative_matrix_flexible_dimensions_properties_nv;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_physical_device_cooperative_matrix_flexible_dimensions_properties_nv(
				&fixture.instance,
				std::mem::zeroed::<vk::PhysicalDevice>(),
				std::mem::zeroed::<*mut u32>(),
				std::mem::zeroed::<*mut vk::CooperativeMatrixFlexibleDimensionsPropertiesNV<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV"
			))
		));
		assert!(matches!(
			fixture
				.instance
				.get_physical_device_cooperative_matrix_flexible_dimensions_properties_nv(
					std::mem::zeroed::<vk::PhysicalDevice>(),
					std::mem::zeroed::<*mut u32>(),
					std::mem::zeroed::<*mut vk::CooperativeMatrixFlexibleDimensionsPropertiesNV<'_>>()
				),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV"
			))
		));
	}
}

#[test]
fn get_physical_device_cooperative_matrix_flexible_dimensions_properties_nv_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::PhysicalDevice,
		arg_1: *mut u32,
		arg_2: *mut vk::CooperativeMatrixFlexibleDimensionsPropertiesNV<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::PhysicalDevice::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016) as *mut u32,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::CooperativeMatrixFlexibleDimensionsPropertiesNV<'_>,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV =
			Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(
			c"vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV",
			erased,
		);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_physical_device_cooperative_matrix_flexible_dimensions_properties_nv(
					&fixture.instance,
					vk::PhysicalDevice::from_raw(305397760_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016) as *mut u32,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::CooperativeMatrixFlexibleDimensionsPropertiesNV<'_>
				),
				expected
			);
			assert_eq!(
				vk::Instance::get_physical_device_cooperative_matrix_flexible_dimensions_properties_nv(
					&fixture.instance,
					vk::PhysicalDevice::from_raw(305397760_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016) as *mut u32,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::CooperativeMatrixFlexibleDimensionsPropertiesNV<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[cfg(feature = "platform-metal")]
#[test]
fn get_memory_metal_handle_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::MemoryGetMetalHandleInfoEXT<'_>,
		*mut *mut std::ffi::c_void,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_memory_metal_handle_ext;
	let _: Signature = vk::Device::get_memory_metal_handle_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_memory_metal_handle_ext(
				&fixture.device,
				std::mem::zeroed::<*const vk::MemoryGetMetalHandleInfoEXT<'_>>(),
				std::mem::zeroed::<*mut *mut std::ffi::c_void>()
			),
			Err(CallError::MissingCommand("vkGetMemoryMetalHandleEXT"))
		));
		assert!(matches!(
			fixture.device.get_memory_metal_handle_ext(
				std::mem::zeroed::<*const vk::MemoryGetMetalHandleInfoEXT<'_>>(),
				std::mem::zeroed::<*mut *mut std::ffi::c_void>()
			),
			Err(CallError::MissingCommand("vkGetMemoryMetalHandleEXT"))
		));
	}
}

#[cfg(feature = "platform-metal")]
#[test]
fn get_memory_metal_handle_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::MemoryGetMetalHandleInfoEXT<'_>,
		arg_2: *mut *mut std::ffi::c_void,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::MemoryGetMetalHandleInfoEXT<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut *mut std::ffi::c_void,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetMemoryMetalHandleEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkGetMemoryMetalHandleEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkGetMemoryMetalHandleEXT", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_memory_metal_handle_ext(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::MemoryGetMetalHandleInfoEXT<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut *mut std::ffi::c_void
				),
				expected
			);
			assert_eq!(
				vk::Device::get_memory_metal_handle_ext(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::MemoryGetMetalHandleInfoEXT<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut *mut std::ffi::c_void
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[cfg(feature = "platform-metal")]
#[test]
fn get_memory_metal_handle_properties_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::ExternalMemoryHandleTypeFlagBits,
		*const std::ffi::c_void,
		*mut vk::MemoryMetalHandlePropertiesEXT<'_>,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_memory_metal_handle_properties_ext;
	let _: Signature = vk::Device::get_memory_metal_handle_properties_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_memory_metal_handle_properties_ext(
				&fixture.device,
				std::mem::zeroed::<vk::ExternalMemoryHandleTypeFlagBits>(),
				std::mem::zeroed::<*const std::ffi::c_void>(),
				std::mem::zeroed::<*mut vk::MemoryMetalHandlePropertiesEXT<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetMemoryMetalHandlePropertiesEXT"
			))
		));
		assert!(matches!(
			fixture.device.get_memory_metal_handle_properties_ext(
				std::mem::zeroed::<vk::ExternalMemoryHandleTypeFlagBits>(),
				std::mem::zeroed::<*const std::ffi::c_void>(),
				std::mem::zeroed::<*mut vk::MemoryMetalHandlePropertiesEXT<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetMemoryMetalHandlePropertiesEXT"
			))
		));
	}
}

#[cfg(feature = "platform-metal")]
#[test]
fn get_memory_metal_handle_properties_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::ExternalMemoryHandleTypeFlagBits,
		arg_2: *const std::ffi::c_void,
		arg_3: *mut vk::MemoryMetalHandlePropertiesEXT<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::ExternalMemoryHandleTypeFlagBits::from_raw(305398016_u64 as _)
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *const std::ffi::c_void,
					) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::MemoryMetalHandlePropertiesEXT<'_>,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetMemoryMetalHandlePropertiesEXT = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetMemoryMetalHandlePropertiesEXT,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkGetMemoryMetalHandlePropertiesEXT", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_memory_metal_handle_properties_ext(
					&fixture.device,
					vk::ExternalMemoryHandleTypeFlagBits::from_raw(305398016_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const std::ffi::c_void,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::MemoryMetalHandlePropertiesEXT<'_>
				),
				expected
			);
			assert_eq!(
				vk::Device::get_memory_metal_handle_properties_ext(
					&fixture.device,
					vk::ExternalMemoryHandleTypeFlagBits::from_raw(305398016_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const std::ffi::c_void,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::MemoryMetalHandlePropertiesEXT<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_physical_device_cooperative_vector_properties_nv_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		vk::PhysicalDevice,
		*mut u32,
		*mut vk::CooperativeVectorPropertiesNV<'_>,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_physical_device_cooperative_vector_properties_nv;
	let _: Signature = vk::Instance::get_physical_device_cooperative_vector_properties_nv;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_physical_device_cooperative_vector_properties_nv(
				&fixture.instance,
				std::mem::zeroed::<vk::PhysicalDevice>(),
				std::mem::zeroed::<*mut u32>(),
				std::mem::zeroed::<*mut vk::CooperativeVectorPropertiesNV<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceCooperativeVectorPropertiesNV"
			))
		));
		assert!(matches!(
			fixture
				.instance
				.get_physical_device_cooperative_vector_properties_nv(
					std::mem::zeroed::<vk::PhysicalDevice>(),
					std::mem::zeroed::<*mut u32>(),
					std::mem::zeroed::<*mut vk::CooperativeVectorPropertiesNV<'_>>()
				),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceCooperativeVectorPropertiesNV"
			))
		));
	}
}

#[test]
fn get_physical_device_cooperative_vector_properties_nv_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::PhysicalDevice,
		arg_1: *mut u32,
		arg_2: *mut vk::CooperativeVectorPropertiesNV<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::PhysicalDevice::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016) as *mut u32,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::CooperativeVectorPropertiesNV<'_>,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetPhysicalDeviceCooperativeVectorPropertiesNV = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetPhysicalDeviceCooperativeVectorPropertiesNV,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture =
			Fixture::new_with_command(c"vkGetPhysicalDeviceCooperativeVectorPropertiesNV", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_physical_device_cooperative_vector_properties_nv(
					&fixture.instance,
					vk::PhysicalDevice::from_raw(305397760_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016) as *mut u32,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::CooperativeVectorPropertiesNV<'_>
				),
				expected
			);
			assert_eq!(
				vk::Instance::get_physical_device_cooperative_vector_properties_nv(
					&fixture.instance,
					vk::PhysicalDevice::from_raw(305397760_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016) as *mut u32,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::CooperativeVectorPropertiesNV<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn convert_cooperative_vector_matrix_nv_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::ConvertCooperativeVectorMatrixInfoNV<'_>,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::convert_cooperative_vector_matrix_nv;
	let _: Signature = vk::Device::convert_cooperative_vector_matrix_nv;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::convert_cooperative_vector_matrix_nv(
				&fixture.device,
				std::mem::zeroed::<*const vk::ConvertCooperativeVectorMatrixInfoNV<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkConvertCooperativeVectorMatrixNV"
			))
		));
		assert!(matches!(
			fixture
				.device
				.convert_cooperative_vector_matrix_nv(std::mem::zeroed::<
					*const vk::ConvertCooperativeVectorMatrixInfoNV<'_>,
				>()),
			Err(CallError::MissingCommand(
				"vkConvertCooperativeVectorMatrixNV"
			))
		));
	}
}

#[test]
fn convert_cooperative_vector_matrix_nv_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::ConvertCooperativeVectorMatrixInfoNV<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::ConvertCooperativeVectorMatrixInfoNV<'_>,
					)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkConvertCooperativeVectorMatrixNV = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkConvertCooperativeVectorMatrixNV,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkConvertCooperativeVectorMatrixNV", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::convert_cooperative_vector_matrix_nv(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::ConvertCooperativeVectorMatrixInfoNV<'_>
				),
				expected
			);
			assert_eq!(
				vk::Device::convert_cooperative_vector_matrix_nv(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::ConvertCooperativeVectorMatrixInfoNV<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_convert_cooperative_vector_matrix_nv_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		u32,
		*const vk::ConvertCooperativeVectorMatrixInfoNV<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_convert_cooperative_vector_matrix_nv;
	let _: Signature = vk::Device::cmd_convert_cooperative_vector_matrix_nv;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_convert_cooperative_vector_matrix_nv(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::ConvertCooperativeVectorMatrixInfoNV<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkCmdConvertCooperativeVectorMatrixNV"
			))
		));
		assert!(matches!(
			fixture.device.cmd_convert_cooperative_vector_matrix_nv(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::ConvertCooperativeVectorMatrixInfoNV<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkCmdConvertCooperativeVectorMatrixNV"
			))
		));
	}
}

#[test]
fn cmd_convert_cooperative_vector_matrix_nv_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: u32,
		arg_2: *const vk::ConvertCooperativeVectorMatrixInfoNV<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == Default::default()
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *const vk::ConvertCooperativeVectorMatrixInfoNV<'_>,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdConvertCooperativeVectorMatrixNV = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkCmdConvertCooperativeVectorMatrixNV,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdConvertCooperativeVectorMatrixNV", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_convert_cooperative_vector_matrix_nv(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::ConvertCooperativeVectorMatrixInfoNV<'_>,
		)
		.unwrap();
		vk::Device::cmd_convert_cooperative_vector_matrix_nv(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::ConvertCooperativeVectorMatrixInfoNV<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_dispatch_tile_qcom_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		*const vk::DispatchTileInfoQCOM<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_dispatch_tile_qcom;
	let _: Signature = vk::Device::cmd_dispatch_tile_qcom;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_dispatch_tile_qcom(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::DispatchTileInfoQCOM<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdDispatchTileQCOM"))
		));
		assert!(matches!(
			fixture.device.cmd_dispatch_tile_qcom(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::DispatchTileInfoQCOM<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdDispatchTileQCOM"))
		));
	}
}

#[test]
fn cmd_dispatch_tile_qcom_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: *const vk::DispatchTileInfoQCOM<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::DispatchTileInfoQCOM<'_>,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdDispatchTileQCOM = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdDispatchTileQCOM, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdDispatchTileQCOM", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_dispatch_tile_qcom(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::DispatchTileInfoQCOM<'_>,
		)
		.unwrap();
		vk::Device::cmd_dispatch_tile_qcom(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::DispatchTileInfoQCOM<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_begin_per_tile_execution_qcom_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		*const vk::PerTileBeginInfoQCOM<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_begin_per_tile_execution_qcom;
	let _: Signature = vk::Device::cmd_begin_per_tile_execution_qcom;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_begin_per_tile_execution_qcom(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::PerTileBeginInfoQCOM<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdBeginPerTileExecutionQCOM"))
		));
		assert!(matches!(
			fixture.device.cmd_begin_per_tile_execution_qcom(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::PerTileBeginInfoQCOM<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdBeginPerTileExecutionQCOM"))
		));
	}
}

#[test]
fn cmd_begin_per_tile_execution_qcom_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: *const vk::PerTileBeginInfoQCOM<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::PerTileBeginInfoQCOM<'_>,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdBeginPerTileExecutionQCOM = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdBeginPerTileExecutionQCOM, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdBeginPerTileExecutionQCOM", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_begin_per_tile_execution_qcom(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::PerTileBeginInfoQCOM<'_>,
		)
		.unwrap();
		vk::Device::cmd_begin_per_tile_execution_qcom(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::PerTileBeginInfoQCOM<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_end_per_tile_execution_qcom_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		*const vk::PerTileEndInfoQCOM<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_end_per_tile_execution_qcom;
	let _: Signature = vk::Device::cmd_end_per_tile_execution_qcom;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_end_per_tile_execution_qcom(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::PerTileEndInfoQCOM<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdEndPerTileExecutionQCOM"))
		));
		assert!(matches!(
			fixture.device.cmd_end_per_tile_execution_qcom(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::PerTileEndInfoQCOM<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdEndPerTileExecutionQCOM"))
		));
	}
}

#[test]
fn cmd_end_per_tile_execution_qcom_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: *const vk::PerTileEndInfoQCOM<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::PerTileEndInfoQCOM<'_>,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdEndPerTileExecutionQCOM = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdEndPerTileExecutionQCOM, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdEndPerTileExecutionQCOM", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_end_per_tile_execution_qcom(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::PerTileEndInfoQCOM<'_>,
		)
		.unwrap();
		vk::Device::cmd_end_per_tile_execution_qcom(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::PerTileEndInfoQCOM<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn create_external_compute_queue_nv_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::ExternalComputeQueueCreateInfoNV<'_>,
		*const vk::AllocationCallbacks,
		*mut vk::ExternalComputeQueueNV,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::create_external_compute_queue_nv;
	let _: Signature = vk::Device::create_external_compute_queue_nv;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::create_external_compute_queue_nv(
				&fixture.device,
				std::mem::zeroed::<*const vk::ExternalComputeQueueCreateInfoNV<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::ExternalComputeQueueNV>()
			),
			Err(CallError::MissingCommand("vkCreateExternalComputeQueueNV"))
		));
		assert!(matches!(
			fixture.device.create_external_compute_queue_nv(
				std::mem::zeroed::<*const vk::ExternalComputeQueueCreateInfoNV<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::ExternalComputeQueueNV>()
			),
			Err(CallError::MissingCommand("vkCreateExternalComputeQueueNV"))
		));
	}
}

#[test]
fn create_external_compute_queue_nv_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::ExternalComputeQueueCreateInfoNV<'_>,
		arg_2: *const vk::AllocationCallbacks,
		arg_3: *mut vk::ExternalComputeQueueNV,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::ExternalComputeQueueCreateInfoNV<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
				) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::ExternalComputeQueueNV,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCreateExternalComputeQueueNV = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCreateExternalComputeQueueNV, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCreateExternalComputeQueueNV", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::create_external_compute_queue_nv(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::ExternalComputeQueueCreateInfoNV<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::ExternalComputeQueueNV
				),
				expected
			);
			assert_eq!(
				vk::Device::create_external_compute_queue_nv(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::ExternalComputeQueueCreateInfoNV<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::ExternalComputeQueueNV
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn destroy_external_compute_queue_nv_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::ExternalComputeQueueNV,
		*const vk::AllocationCallbacks,
	) -> Result<(), CallError>;
	let _: Signature = vk::destroy_external_compute_queue_nv;
	let _: Signature = vk::Device::destroy_external_compute_queue_nv;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::destroy_external_compute_queue_nv(
				&fixture.device,
				std::mem::zeroed::<vk::ExternalComputeQueueNV>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>()
			),
			Err(CallError::MissingCommand("vkDestroyExternalComputeQueueNV"))
		));
		assert!(matches!(
			fixture.device.destroy_external_compute_queue_nv(
				std::mem::zeroed::<vk::ExternalComputeQueueNV>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>()
			),
			Err(CallError::MissingCommand("vkDestroyExternalComputeQueueNV"))
		));
	}
}

#[test]
fn destroy_external_compute_queue_nv_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::ExternalComputeQueueNV,
		arg_2: *const vk::AllocationCallbacks,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::ExternalComputeQueueNV::from_raw(305398016_u64 as _)
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *const vk::AllocationCallbacks,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkDestroyExternalComputeQueueNV = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkDestroyExternalComputeQueueNV, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkDestroyExternalComputeQueueNV", erased);
		let resolutions = Fixture::query_count();
		vk::destroy_external_compute_queue_nv(
			&fixture.device,
			vk::ExternalComputeQueueNV::from_raw(305398016_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::AllocationCallbacks,
		)
		.unwrap();
		vk::Device::destroy_external_compute_queue_nv(
			&fixture.device,
			vk::ExternalComputeQueueNV::from_raw(305398016_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::AllocationCallbacks,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_external_compute_queue_data_nv_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::ExternalComputeQueueNV,
		*mut vk::ExternalComputeQueueDataParamsNV<'_>,
		*mut std::ffi::c_void,
	) -> Result<(), CallError>;
	let _: Signature = vk::get_external_compute_queue_data_nv;
	let _: Signature = vk::Device::get_external_compute_queue_data_nv;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_external_compute_queue_data_nv(
				&fixture.device,
				std::mem::zeroed::<vk::ExternalComputeQueueNV>(),
				std::mem::zeroed::<*mut vk::ExternalComputeQueueDataParamsNV<'_>>(),
				std::mem::zeroed::<*mut std::ffi::c_void>()
			),
			Err(CallError::MissingCommand("vkGetExternalComputeQueueDataNV"))
		));
		assert!(matches!(
			fixture.device.get_external_compute_queue_data_nv(
				std::mem::zeroed::<vk::ExternalComputeQueueNV>(),
				std::mem::zeroed::<*mut vk::ExternalComputeQueueDataParamsNV<'_>>(),
				std::mem::zeroed::<*mut std::ffi::c_void>()
			),
			Err(CallError::MissingCommand("vkGetExternalComputeQueueDataNV"))
		));
	}
}

#[test]
fn get_external_compute_queue_data_nv_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::ExternalComputeQueueNV,
		arg_1: *mut vk::ExternalComputeQueueDataParamsNV<'_>,
		arg_2: *mut std::ffi::c_void,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::ExternalComputeQueueNV::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *mut vk::ExternalComputeQueueDataParamsNV<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272),
				)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetExternalComputeQueueDataNV = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkGetExternalComputeQueueDataNV, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkGetExternalComputeQueueDataNV", erased);
		let resolutions = Fixture::query_count();
		vk::get_external_compute_queue_data_nv(
			&fixture.device,
			vk::ExternalComputeQueueNV::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *mut vk::ExternalComputeQueueDataParamsNV<'_>,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272),
		)
		.unwrap();
		vk::Device::get_external_compute_queue_data_nv(
			&fixture.device,
			vk::ExternalComputeQueueNV::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *mut vk::ExternalComputeQueueDataParamsNV<'_>,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272),
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn enumerate_physical_device_shader_instrumentation_metrics_arm_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		vk::PhysicalDevice,
		*mut u32,
		*mut vk::ShaderInstrumentationMetricDescriptionARM<'_>,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::enumerate_physical_device_shader_instrumentation_metrics_arm;
	let _: Signature = vk::Instance::enumerate_physical_device_shader_instrumentation_metrics_arm;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::enumerate_physical_device_shader_instrumentation_metrics_arm(
				&fixture.instance,
				std::mem::zeroed::<vk::PhysicalDevice>(),
				std::mem::zeroed::<*mut u32>(),
				std::mem::zeroed::<*mut vk::ShaderInstrumentationMetricDescriptionARM<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkEnumeratePhysicalDeviceShaderInstrumentationMetricsARM"
			))
		));
		assert!(matches!(
			fixture
				.instance
				.enumerate_physical_device_shader_instrumentation_metrics_arm(
					std::mem::zeroed::<vk::PhysicalDevice>(),
					std::mem::zeroed::<*mut u32>(),
					std::mem::zeroed::<*mut vk::ShaderInstrumentationMetricDescriptionARM<'_>>()
				),
			Err(CallError::MissingCommand(
				"vkEnumeratePhysicalDeviceShaderInstrumentationMetricsARM"
			))
		));
	}
}

#[test]
fn enumerate_physical_device_shader_instrumentation_metrics_arm_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::PhysicalDevice,
		arg_1: *mut u32,
		arg_2: *mut vk::ShaderInstrumentationMetricDescriptionARM<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::PhysicalDevice::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016) as *mut u32,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::ShaderInstrumentationMetricDescriptionARM<'_>,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkEnumeratePhysicalDeviceShaderInstrumentationMetricsARM = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkEnumeratePhysicalDeviceShaderInstrumentationMetricsARM,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(
			c"vkEnumeratePhysicalDeviceShaderInstrumentationMetricsARM",
			erased,
		);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::enumerate_physical_device_shader_instrumentation_metrics_arm(
					&fixture.instance,
					vk::PhysicalDevice::from_raw(305397760_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016) as *mut u32,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::ShaderInstrumentationMetricDescriptionARM<'_>
				),
				expected
			);
			assert_eq!(
				vk::Instance::enumerate_physical_device_shader_instrumentation_metrics_arm(
					&fixture.instance,
					vk::PhysicalDevice::from_raw(305397760_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016) as *mut u32,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::ShaderInstrumentationMetricDescriptionARM<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn create_shader_instrumentation_arm_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::ShaderInstrumentationCreateInfoARM<'_>,
		*const vk::AllocationCallbacks,
		*mut vk::ShaderInstrumentationARM,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::create_shader_instrumentation_arm;
	let _: Signature = vk::Device::create_shader_instrumentation_arm;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::create_shader_instrumentation_arm(
				&fixture.device,
				std::mem::zeroed::<*const vk::ShaderInstrumentationCreateInfoARM<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::ShaderInstrumentationARM>()
			),
			Err(CallError::MissingCommand(
				"vkCreateShaderInstrumentationARM"
			))
		));
		assert!(matches!(
			fixture.device.create_shader_instrumentation_arm(
				std::mem::zeroed::<*const vk::ShaderInstrumentationCreateInfoARM<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::ShaderInstrumentationARM>()
			),
			Err(CallError::MissingCommand(
				"vkCreateShaderInstrumentationARM"
			))
		));
	}
}

#[test]
fn create_shader_instrumentation_arm_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::ShaderInstrumentationCreateInfoARM<'_>,
		arg_2: *const vk::AllocationCallbacks,
		arg_3: *mut vk::ShaderInstrumentationARM,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::ShaderInstrumentationCreateInfoARM<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
				) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::ShaderInstrumentationARM,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCreateShaderInstrumentationARM = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkCreateShaderInstrumentationARM,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkCreateShaderInstrumentationARM", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::create_shader_instrumentation_arm(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::ShaderInstrumentationCreateInfoARM<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::ShaderInstrumentationARM
				),
				expected
			);
			assert_eq!(
				vk::Device::create_shader_instrumentation_arm(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::ShaderInstrumentationCreateInfoARM<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::ShaderInstrumentationARM
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn destroy_shader_instrumentation_arm_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::ShaderInstrumentationARM,
		*const vk::AllocationCallbacks,
	) -> Result<(), CallError>;
	let _: Signature = vk::destroy_shader_instrumentation_arm;
	let _: Signature = vk::Device::destroy_shader_instrumentation_arm;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::destroy_shader_instrumentation_arm(
				&fixture.device,
				std::mem::zeroed::<vk::ShaderInstrumentationARM>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>()
			),
			Err(CallError::MissingCommand(
				"vkDestroyShaderInstrumentationARM"
			))
		));
		assert!(matches!(
			fixture.device.destroy_shader_instrumentation_arm(
				std::mem::zeroed::<vk::ShaderInstrumentationARM>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>()
			),
			Err(CallError::MissingCommand(
				"vkDestroyShaderInstrumentationARM"
			))
		));
	}
}

#[test]
fn destroy_shader_instrumentation_arm_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::ShaderInstrumentationARM,
		arg_2: *const vk::AllocationCallbacks,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::ShaderInstrumentationARM::from_raw(305398016_u64 as _)
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *const vk::AllocationCallbacks,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkDestroyShaderInstrumentationARM = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkDestroyShaderInstrumentationARM,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkDestroyShaderInstrumentationARM", erased);
		let resolutions = Fixture::query_count();
		vk::destroy_shader_instrumentation_arm(
			&fixture.device,
			vk::ShaderInstrumentationARM::from_raw(305398016_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::AllocationCallbacks,
		)
		.unwrap();
		vk::Device::destroy_shader_instrumentation_arm(
			&fixture.device,
			vk::ShaderInstrumentationARM::from_raw(305398016_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::AllocationCallbacks,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_begin_shader_instrumentation_arm_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		vk::ShaderInstrumentationARM,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_begin_shader_instrumentation_arm;
	let _: Signature = vk::Device::cmd_begin_shader_instrumentation_arm;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_begin_shader_instrumentation_arm(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::ShaderInstrumentationARM>()
			),
			Err(CallError::MissingCommand(
				"vkCmdBeginShaderInstrumentationARM"
			))
		));
		assert!(matches!(
			fixture.device.cmd_begin_shader_instrumentation_arm(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::ShaderInstrumentationARM>()
			),
			Err(CallError::MissingCommand(
				"vkCmdBeginShaderInstrumentationARM"
			))
		));
	}
}

#[test]
fn cmd_begin_shader_instrumentation_arm_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::CommandBuffer, arg_1: vk::ShaderInstrumentationARM) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == vk::ShaderInstrumentationARM::from_raw(305398016_u64 as _)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdBeginShaderInstrumentationARM = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkCmdBeginShaderInstrumentationARM,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdBeginShaderInstrumentationARM", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_begin_shader_instrumentation_arm(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::ShaderInstrumentationARM::from_raw(305398016_u64 as _),
		)
		.unwrap();
		vk::Device::cmd_begin_shader_instrumentation_arm(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::ShaderInstrumentationARM::from_raw(305398016_u64 as _),
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_end_shader_instrumentation_arm_signature_and_missing_command() {
	type Signature = unsafe fn(&vk::Device, vk::CommandBuffer) -> Result<(), CallError>;
	let _: Signature = vk::cmd_end_shader_instrumentation_arm;
	let _: Signature = vk::Device::cmd_end_shader_instrumentation_arm;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_end_shader_instrumentation_arm(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>()
			),
			Err(CallError::MissingCommand(
				"vkCmdEndShaderInstrumentationARM"
			))
		));
		assert!(matches!(
			fixture
				.device
				.cmd_end_shader_instrumentation_arm(std::mem::zeroed::<vk::CommandBuffer>()),
			Err(CallError::MissingCommand(
				"vkCmdEndShaderInstrumentationARM"
			))
		));
	}
}

#[test]
fn cmd_end_shader_instrumentation_arm_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::CommandBuffer) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(MATCHED.get() && (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)));
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdEndShaderInstrumentationARM = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkCmdEndShaderInstrumentationARM,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdEndShaderInstrumentationARM", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_end_shader_instrumentation_arm(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
		)
		.unwrap();
		vk::Device::cmd_end_shader_instrumentation_arm(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_shader_instrumentation_values_arm_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::ShaderInstrumentationARM,
		*mut u32,
		*mut std::ffi::c_void,
		vk::ShaderInstrumentationValuesFlagsARM,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_shader_instrumentation_values_arm;
	let _: Signature = vk::Device::get_shader_instrumentation_values_arm;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_shader_instrumentation_values_arm(
				&fixture.device,
				std::mem::zeroed::<vk::ShaderInstrumentationARM>(),
				std::mem::zeroed::<*mut u32>(),
				std::mem::zeroed::<*mut std::ffi::c_void>(),
				std::mem::zeroed::<vk::ShaderInstrumentationValuesFlagsARM>()
			),
			Err(CallError::MissingCommand(
				"vkGetShaderInstrumentationValuesARM"
			))
		));
		assert!(matches!(
			fixture.device.get_shader_instrumentation_values_arm(
				std::mem::zeroed::<vk::ShaderInstrumentationARM>(),
				std::mem::zeroed::<*mut u32>(),
				std::mem::zeroed::<*mut std::ffi::c_void>(),
				std::mem::zeroed::<vk::ShaderInstrumentationValuesFlagsARM>()
			),
			Err(CallError::MissingCommand(
				"vkGetShaderInstrumentationValuesARM"
			))
		));
	}
}

#[test]
fn get_shader_instrumentation_values_arm_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::ShaderInstrumentationARM,
		arg_2: *mut u32,
		arg_3: *mut std::ffi::c_void,
		arg_4: vk::ShaderInstrumentationValuesFlagsARM,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::ShaderInstrumentationARM::from_raw(305398016_u64 as _)
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut u32,
					) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528),
				) && arg_4 == vk::ShaderInstrumentationValuesFlagsARM::from_raw(305398784_u64 as _)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetShaderInstrumentationValuesARM = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetShaderInstrumentationValuesARM,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkGetShaderInstrumentationValuesARM", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_shader_instrumentation_values_arm(
					&fixture.device,
					vk::ShaderInstrumentationARM::from_raw(305398016_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut u32,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528),
					vk::ShaderInstrumentationValuesFlagsARM::from_raw(305398784_u64 as _)
				),
				expected
			);
			assert_eq!(
				vk::Device::get_shader_instrumentation_values_arm(
					&fixture.device,
					vk::ShaderInstrumentationARM::from_raw(305398016_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut u32,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528),
					vk::ShaderInstrumentationValuesFlagsARM::from_raw(305398784_u64 as _)
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn clear_shader_instrumentation_metrics_arm_signature_and_missing_command() {
	type Signature = unsafe fn(&vk::Device, vk::ShaderInstrumentationARM) -> Result<(), CallError>;
	let _: Signature = vk::clear_shader_instrumentation_metrics_arm;
	let _: Signature = vk::Device::clear_shader_instrumentation_metrics_arm;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::clear_shader_instrumentation_metrics_arm(
				&fixture.device,
				std::mem::zeroed::<vk::ShaderInstrumentationARM>()
			),
			Err(CallError::MissingCommand(
				"vkClearShaderInstrumentationMetricsARM"
			))
		));
		assert!(matches!(
			fixture
				.device
				.clear_shader_instrumentation_metrics_arm(
					std::mem::zeroed::<vk::ShaderInstrumentationARM>()
				),
			Err(CallError::MissingCommand(
				"vkClearShaderInstrumentationMetricsARM"
			))
		));
	}
}

#[test]
fn clear_shader_instrumentation_metrics_arm_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::DeviceHandle, arg_1: vk::ShaderInstrumentationARM) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::ShaderInstrumentationARM::from_raw(305398016_u64 as _)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkClearShaderInstrumentationMetricsARM = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkClearShaderInstrumentationMetricsARM,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkClearShaderInstrumentationMetricsARM", erased);
		let resolutions = Fixture::query_count();
		vk::clear_shader_instrumentation_metrics_arm(
			&fixture.device,
			vk::ShaderInstrumentationARM::from_raw(305398016_u64 as _),
		)
		.unwrap();
		vk::Device::clear_shader_instrumentation_metrics_arm(
			&fixture.device,
			vk::ShaderInstrumentationARM::from_raw(305398016_u64 as _),
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn create_tensor_arm_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::TensorCreateInfoARM<'_>,
		*const vk::AllocationCallbacks,
		*mut vk::TensorARM,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::create_tensor_arm;
	let _: Signature = vk::Device::create_tensor_arm;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::create_tensor_arm(
				&fixture.device,
				std::mem::zeroed::<*const vk::TensorCreateInfoARM<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::TensorARM>()
			),
			Err(CallError::MissingCommand("vkCreateTensorARM"))
		));
		assert!(matches!(
			fixture.device.create_tensor_arm(
				std::mem::zeroed::<*const vk::TensorCreateInfoARM<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::TensorARM>()
			),
			Err(CallError::MissingCommand("vkCreateTensorARM"))
		));
	}
}

#[test]
fn create_tensor_arm_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::TensorCreateInfoARM<'_>,
		arg_2: *const vk::AllocationCallbacks,
		arg_3: *mut vk::TensorARM,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::TensorCreateInfoARM<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
				) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::TensorARM,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCreateTensorARM = Some(mock);
		let erased = std::mem::transmute::<vk::PFN_vkCreateTensorARM, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCreateTensorARM", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::create_tensor_arm(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::TensorCreateInfoARM<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::TensorARM
				),
				expected
			);
			assert_eq!(
				vk::Device::create_tensor_arm(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::TensorCreateInfoARM<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::TensorARM
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn destroy_tensor_arm_signature_and_missing_command() {
	type Signature =
		unsafe fn(&vk::Device, vk::TensorARM, *const vk::AllocationCallbacks) -> Result<(), CallError>;
	let _: Signature = vk::destroy_tensor_arm;
	let _: Signature = vk::Device::destroy_tensor_arm;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::destroy_tensor_arm(
				&fixture.device,
				std::mem::zeroed::<vk::TensorARM>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>()
			),
			Err(CallError::MissingCommand("vkDestroyTensorARM"))
		));
		assert!(matches!(
			fixture.device.destroy_tensor_arm(
				std::mem::zeroed::<vk::TensorARM>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>()
			),
			Err(CallError::MissingCommand("vkDestroyTensorARM"))
		));
	}
}

#[test]
fn destroy_tensor_arm_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::TensorARM,
		arg_2: *const vk::AllocationCallbacks,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::TensorARM::from_raw(305398016_u64 as _)
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *const vk::AllocationCallbacks,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkDestroyTensorARM = Some(mock);
		let erased = std::mem::transmute::<vk::PFN_vkDestroyTensorARM, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkDestroyTensorARM", erased);
		let resolutions = Fixture::query_count();
		vk::destroy_tensor_arm(
			&fixture.device,
			vk::TensorARM::from_raw(305398016_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::AllocationCallbacks,
		)
		.unwrap();
		vk::Device::destroy_tensor_arm(
			&fixture.device,
			vk::TensorARM::from_raw(305398016_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::AllocationCallbacks,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn create_tensor_view_arm_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::TensorViewCreateInfoARM<'_>,
		*const vk::AllocationCallbacks,
		*mut vk::TensorViewARM,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::create_tensor_view_arm;
	let _: Signature = vk::Device::create_tensor_view_arm;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::create_tensor_view_arm(
				&fixture.device,
				std::mem::zeroed::<*const vk::TensorViewCreateInfoARM<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::TensorViewARM>()
			),
			Err(CallError::MissingCommand("vkCreateTensorViewARM"))
		));
		assert!(matches!(
			fixture.device.create_tensor_view_arm(
				std::mem::zeroed::<*const vk::TensorViewCreateInfoARM<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::TensorViewARM>()
			),
			Err(CallError::MissingCommand("vkCreateTensorViewARM"))
		));
	}
}

#[test]
fn create_tensor_view_arm_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::TensorViewCreateInfoARM<'_>,
		arg_2: *const vk::AllocationCallbacks,
		arg_3: *mut vk::TensorViewARM,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::TensorViewCreateInfoARM<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
				) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::TensorViewARM,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCreateTensorViewARM = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCreateTensorViewARM, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCreateTensorViewARM", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::create_tensor_view_arm(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::TensorViewCreateInfoARM<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::TensorViewARM
				),
				expected
			);
			assert_eq!(
				vk::Device::create_tensor_view_arm(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::TensorViewCreateInfoARM<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut vk::TensorViewARM
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn destroy_tensor_view_arm_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::TensorViewARM,
		*const vk::AllocationCallbacks,
	) -> Result<(), CallError>;
	let _: Signature = vk::destroy_tensor_view_arm;
	let _: Signature = vk::Device::destroy_tensor_view_arm;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::destroy_tensor_view_arm(
				&fixture.device,
				std::mem::zeroed::<vk::TensorViewARM>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>()
			),
			Err(CallError::MissingCommand("vkDestroyTensorViewARM"))
		));
		assert!(matches!(
			fixture.device.destroy_tensor_view_arm(
				std::mem::zeroed::<vk::TensorViewARM>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>()
			),
			Err(CallError::MissingCommand("vkDestroyTensorViewARM"))
		));
	}
}

#[test]
fn destroy_tensor_view_arm_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::TensorViewARM,
		arg_2: *const vk::AllocationCallbacks,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::TensorViewARM::from_raw(305398016_u64 as _)
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *const vk::AllocationCallbacks,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkDestroyTensorViewARM = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkDestroyTensorViewARM, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkDestroyTensorViewARM", erased);
		let resolutions = Fixture::query_count();
		vk::destroy_tensor_view_arm(
			&fixture.device,
			vk::TensorViewARM::from_raw(305398016_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::AllocationCallbacks,
		)
		.unwrap();
		vk::Device::destroy_tensor_view_arm(
			&fixture.device,
			vk::TensorViewARM::from_raw(305398016_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::AllocationCallbacks,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_tensor_memory_requirements_arm_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::TensorMemoryRequirementsInfoARM<'_>,
		*mut vk::MemoryRequirements2<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::get_tensor_memory_requirements_arm;
	let _: Signature = vk::Device::get_tensor_memory_requirements_arm;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_tensor_memory_requirements_arm(
				&fixture.device,
				std::mem::zeroed::<*const vk::TensorMemoryRequirementsInfoARM<'_>>(),
				std::mem::zeroed::<*mut vk::MemoryRequirements2<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetTensorMemoryRequirementsARM"
			))
		));
		assert!(matches!(
			fixture.device.get_tensor_memory_requirements_arm(
				std::mem::zeroed::<*const vk::TensorMemoryRequirementsInfoARM<'_>>(),
				std::mem::zeroed::<*mut vk::MemoryRequirements2<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetTensorMemoryRequirementsARM"
			))
		));
	}
}

#[test]
fn get_tensor_memory_requirements_arm_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::TensorMemoryRequirementsInfoARM<'_>,
		arg_2: *mut vk::MemoryRequirements2<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::TensorMemoryRequirementsInfoARM<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::MemoryRequirements2<'_>,
				)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetTensorMemoryRequirementsARM = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetTensorMemoryRequirementsARM,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkGetTensorMemoryRequirementsARM", erased);
		let resolutions = Fixture::query_count();
		vk::get_tensor_memory_requirements_arm(
			&fixture.device,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::TensorMemoryRequirementsInfoARM<'_>,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *mut vk::MemoryRequirements2<'_>,
		)
		.unwrap();
		vk::Device::get_tensor_memory_requirements_arm(
			&fixture.device,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::TensorMemoryRequirementsInfoARM<'_>,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *mut vk::MemoryRequirements2<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn bind_tensor_memory_arm_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		u32,
		*const vk::BindTensorMemoryInfoARM<'_>,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::bind_tensor_memory_arm;
	let _: Signature = vk::Device::bind_tensor_memory_arm;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::bind_tensor_memory_arm(
				&fixture.device,
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::BindTensorMemoryInfoARM<'_>>()
			),
			Err(CallError::MissingCommand("vkBindTensorMemoryARM"))
		));
		assert!(matches!(
			fixture.device.bind_tensor_memory_arm(
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::BindTensorMemoryInfoARM<'_>>()
			),
			Err(CallError::MissingCommand("vkBindTensorMemoryARM"))
		));
	}
}

#[test]
fn bind_tensor_memory_arm_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: u32,
		arg_2: *const vk::BindTensorMemoryInfoARM<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == Default::default()
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *const vk::BindTensorMemoryInfoARM<'_>,
					)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkBindTensorMemoryARM = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkBindTensorMemoryARM, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkBindTensorMemoryARM", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::bind_tensor_memory_arm(
					&fixture.device,
					Default::default(),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::BindTensorMemoryInfoARM<'_>
				),
				expected
			);
			assert_eq!(
				vk::Device::bind_tensor_memory_arm(
					&fixture.device,
					Default::default(),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::BindTensorMemoryInfoARM<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_device_tensor_memory_requirements_arm_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::DeviceTensorMemoryRequirementsARM<'_>,
		*mut vk::MemoryRequirements2<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::get_device_tensor_memory_requirements_arm;
	let _: Signature = vk::Device::get_device_tensor_memory_requirements_arm;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_device_tensor_memory_requirements_arm(
				&fixture.device,
				std::mem::zeroed::<*const vk::DeviceTensorMemoryRequirementsARM<'_>>(),
				std::mem::zeroed::<*mut vk::MemoryRequirements2<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetDeviceTensorMemoryRequirementsARM"
			))
		));
		assert!(matches!(
			fixture.device.get_device_tensor_memory_requirements_arm(
				std::mem::zeroed::<*const vk::DeviceTensorMemoryRequirementsARM<'_>>(),
				std::mem::zeroed::<*mut vk::MemoryRequirements2<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetDeviceTensorMemoryRequirementsARM"
			))
		));
	}
}

#[test]
fn get_device_tensor_memory_requirements_arm_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::DeviceTensorMemoryRequirementsARM<'_>,
		arg_2: *mut vk::MemoryRequirements2<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::DeviceTensorMemoryRequirementsARM<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::MemoryRequirements2<'_>,
				)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetDeviceTensorMemoryRequirementsARM = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetDeviceTensorMemoryRequirementsARM,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkGetDeviceTensorMemoryRequirementsARM", erased);
		let resolutions = Fixture::query_count();
		vk::get_device_tensor_memory_requirements_arm(
			&fixture.device,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::DeviceTensorMemoryRequirementsARM<'_>,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *mut vk::MemoryRequirements2<'_>,
		)
		.unwrap();
		vk::Device::get_device_tensor_memory_requirements_arm(
			&fixture.device,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::DeviceTensorMemoryRequirementsARM<'_>,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *mut vk::MemoryRequirements2<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_copy_tensor_arm_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		*const vk::CopyTensorInfoARM<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_copy_tensor_arm;
	let _: Signature = vk::Device::cmd_copy_tensor_arm;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_copy_tensor_arm(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::CopyTensorInfoARM<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdCopyTensorARM"))
		));
		assert!(matches!(
			fixture.device.cmd_copy_tensor_arm(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::CopyTensorInfoARM<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdCopyTensorARM"))
		));
	}
}

#[test]
fn cmd_copy_tensor_arm_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: *const vk::CopyTensorInfoARM<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::CopyTensorInfoARM<'_>,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdCopyTensorARM = Some(mock);
		let erased = std::mem::transmute::<vk::PFN_vkCmdCopyTensorARM, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdCopyTensorARM", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_copy_tensor_arm(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::CopyTensorInfoARM<'_>,
		)
		.unwrap();
		vk::Device::cmd_copy_tensor_arm(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::CopyTensorInfoARM<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_tensor_opaque_capture_descriptor_data_arm_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::TensorCaptureDescriptorDataInfoARM<'_>,
		*mut std::ffi::c_void,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_tensor_opaque_capture_descriptor_data_arm;
	let _: Signature = vk::Device::get_tensor_opaque_capture_descriptor_data_arm;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_tensor_opaque_capture_descriptor_data_arm(
				&fixture.device,
				std::mem::zeroed::<*const vk::TensorCaptureDescriptorDataInfoARM<'_>>(),
				std::mem::zeroed::<*mut std::ffi::c_void>()
			),
			Err(CallError::MissingCommand(
				"vkGetTensorOpaqueCaptureDescriptorDataARM"
			))
		));
		assert!(matches!(
			fixture
				.device
				.get_tensor_opaque_capture_descriptor_data_arm(
					std::mem::zeroed::<*const vk::TensorCaptureDescriptorDataInfoARM<'_>>(),
					std::mem::zeroed::<*mut std::ffi::c_void>()
				),
			Err(CallError::MissingCommand(
				"vkGetTensorOpaqueCaptureDescriptorDataARM"
			))
		));
	}
}

#[test]
fn get_tensor_opaque_capture_descriptor_data_arm_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::TensorCaptureDescriptorDataInfoARM<'_>,
		arg_2: *mut std::ffi::c_void,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::TensorCaptureDescriptorDataInfoARM<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272),
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetTensorOpaqueCaptureDescriptorDataARM = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetTensorOpaqueCaptureDescriptorDataARM,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkGetTensorOpaqueCaptureDescriptorDataARM", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_tensor_opaque_capture_descriptor_data_arm(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::TensorCaptureDescriptorDataInfoARM<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				),
				expected
			);
			assert_eq!(
				vk::Device::get_tensor_opaque_capture_descriptor_data_arm(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::TensorCaptureDescriptorDataInfoARM<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_tensor_view_opaque_capture_descriptor_data_arm_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::TensorViewCaptureDescriptorDataInfoARM<'_>,
		*mut std::ffi::c_void,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_tensor_view_opaque_capture_descriptor_data_arm;
	let _: Signature = vk::Device::get_tensor_view_opaque_capture_descriptor_data_arm;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_tensor_view_opaque_capture_descriptor_data_arm(
				&fixture.device,
				std::mem::zeroed::<*const vk::TensorViewCaptureDescriptorDataInfoARM<'_>>(),
				std::mem::zeroed::<*mut std::ffi::c_void>()
			),
			Err(CallError::MissingCommand(
				"vkGetTensorViewOpaqueCaptureDescriptorDataARM"
			))
		));
		assert!(matches!(
			fixture
				.device
				.get_tensor_view_opaque_capture_descriptor_data_arm(
					std::mem::zeroed::<*const vk::TensorViewCaptureDescriptorDataInfoARM<'_>>(),
					std::mem::zeroed::<*mut std::ffi::c_void>()
				),
			Err(CallError::MissingCommand(
				"vkGetTensorViewOpaqueCaptureDescriptorDataARM"
			))
		));
	}
}

#[test]
fn get_tensor_view_opaque_capture_descriptor_data_arm_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::TensorViewCaptureDescriptorDataInfoARM<'_>,
		arg_2: *mut std::ffi::c_void,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::TensorViewCaptureDescriptorDataInfoARM<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272),
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetTensorViewOpaqueCaptureDescriptorDataARM = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetTensorViewOpaqueCaptureDescriptorDataARM,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture =
			Fixture::new_with_command(c"vkGetTensorViewOpaqueCaptureDescriptorDataARM", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_tensor_view_opaque_capture_descriptor_data_arm(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::TensorViewCaptureDescriptorDataInfoARM<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				),
				expected
			);
			assert_eq!(
				vk::Device::get_tensor_view_opaque_capture_descriptor_data_arm(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::TensorViewCaptureDescriptorDataInfoARM<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_physical_device_external_tensor_properties_arm_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		vk::PhysicalDevice,
		*const vk::PhysicalDeviceExternalTensorInfoARM<'_>,
		*mut vk::ExternalTensorPropertiesARM<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::get_physical_device_external_tensor_properties_arm;
	let _: Signature = vk::Instance::get_physical_device_external_tensor_properties_arm;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_physical_device_external_tensor_properties_arm(
				&fixture.instance,
				std::mem::zeroed::<vk::PhysicalDevice>(),
				std::mem::zeroed::<*const vk::PhysicalDeviceExternalTensorInfoARM<'_>>(),
				std::mem::zeroed::<*mut vk::ExternalTensorPropertiesARM<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceExternalTensorPropertiesARM"
			))
		));
		assert!(matches!(
			fixture
				.instance
				.get_physical_device_external_tensor_properties_arm(
					std::mem::zeroed::<vk::PhysicalDevice>(),
					std::mem::zeroed::<*const vk::PhysicalDeviceExternalTensorInfoARM<'_>>(),
					std::mem::zeroed::<*mut vk::ExternalTensorPropertiesARM<'_>>()
				),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceExternalTensorPropertiesARM"
			))
		));
	}
}

#[test]
fn get_physical_device_external_tensor_properties_arm_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::PhysicalDevice,
		arg_1: *const vk::PhysicalDeviceExternalTensorInfoARM<'_>,
		arg_2: *mut vk::ExternalTensorPropertiesARM<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::PhysicalDevice::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::PhysicalDeviceExternalTensorInfoARM<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::ExternalTensorPropertiesARM<'_>,
				)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetPhysicalDeviceExternalTensorPropertiesARM = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetPhysicalDeviceExternalTensorPropertiesARM,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture =
			Fixture::new_with_command(c"vkGetPhysicalDeviceExternalTensorPropertiesARM", erased);
		let resolutions = Fixture::query_count();
		vk::get_physical_device_external_tensor_properties_arm(
			&fixture.instance,
			vk::PhysicalDevice::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::PhysicalDeviceExternalTensorInfoARM<'_>,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *mut vk::ExternalTensorPropertiesARM<'_>,
		)
		.unwrap();
		vk::Instance::get_physical_device_external_tensor_properties_arm(
			&fixture.instance,
			vk::PhysicalDevice::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::PhysicalDeviceExternalTensorInfoARM<'_>,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *mut vk::ExternalTensorPropertiesARM<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn create_data_graph_pipelines_arm_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::DeferredOperationKHR,
		vk::PipelineCache,
		u32,
		*const vk::DataGraphPipelineCreateInfoARM<'_>,
		*const vk::AllocationCallbacks,
		*mut vk::Pipeline,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::create_data_graph_pipelines_arm;
	let _: Signature = vk::Device::create_data_graph_pipelines_arm;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::create_data_graph_pipelines_arm(
				&fixture.device,
				std::mem::zeroed::<vk::DeferredOperationKHR>(),
				std::mem::zeroed::<vk::PipelineCache>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::DataGraphPipelineCreateInfoARM<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::Pipeline>()
			),
			Err(CallError::MissingCommand("vkCreateDataGraphPipelinesARM"))
		));
		assert!(matches!(
			fixture.device.create_data_graph_pipelines_arm(
				std::mem::zeroed::<vk::DeferredOperationKHR>(),
				std::mem::zeroed::<vk::PipelineCache>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::DataGraphPipelineCreateInfoARM<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::Pipeline>()
			),
			Err(CallError::MissingCommand("vkCreateDataGraphPipelinesARM"))
		));
	}
}

#[test]
fn create_data_graph_pipelines_arm_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::DeferredOperationKHR,
		arg_2: vk::PipelineCache,
		arg_3: u32,
		arg_4: *const vk::DataGraphPipelineCreateInfoARM<'_>,
		arg_5: *const vk::AllocationCallbacks,
		arg_6: *mut vk::Pipeline,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::DeferredOperationKHR::from_raw(305398016_u64 as _)
					&& arg_2 == vk::PipelineCache::from_raw(305398272_u64 as _)
					&& arg_3 == Default::default()
					&& std::ptr::eq(
						arg_4,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784)
							as *const vk::DataGraphPipelineCreateInfoARM<'_>,
					) && std::ptr::eq(
					arg_5,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305399040)
						as *const vk::AllocationCallbacks,
				) && std::ptr::eq(
					arg_6,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305399296) as *mut vk::Pipeline,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCreateDataGraphPipelinesARM = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCreateDataGraphPipelinesARM, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCreateDataGraphPipelinesARM", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::create_data_graph_pipelines_arm(
					&fixture.device,
					vk::DeferredOperationKHR::from_raw(305398016_u64 as _),
					vk::PipelineCache::from_raw(305398272_u64 as _),
					Default::default(),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784)
						as *const vk::DataGraphPipelineCreateInfoARM<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305399040)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305399296) as *mut vk::Pipeline
				),
				expected
			);
			assert_eq!(
				vk::Device::create_data_graph_pipelines_arm(
					&fixture.device,
					vk::DeferredOperationKHR::from_raw(305398016_u64 as _),
					vk::PipelineCache::from_raw(305398272_u64 as _),
					Default::default(),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784)
						as *const vk::DataGraphPipelineCreateInfoARM<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305399040)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305399296) as *mut vk::Pipeline
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn create_data_graph_pipeline_session_arm_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::DataGraphPipelineSessionCreateInfoARM<'_>,
		*const vk::AllocationCallbacks,
		*mut vk::DataGraphPipelineSessionARM,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::create_data_graph_pipeline_session_arm;
	let _: Signature = vk::Device::create_data_graph_pipeline_session_arm;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::create_data_graph_pipeline_session_arm(
				&fixture.device,
				std::mem::zeroed::<*const vk::DataGraphPipelineSessionCreateInfoARM<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::DataGraphPipelineSessionARM>()
			),
			Err(CallError::MissingCommand(
				"vkCreateDataGraphPipelineSessionARM"
			))
		));
		assert!(matches!(
			fixture.device.create_data_graph_pipeline_session_arm(
				std::mem::zeroed::<*const vk::DataGraphPipelineSessionCreateInfoARM<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::DataGraphPipelineSessionARM>()
			),
			Err(CallError::MissingCommand(
				"vkCreateDataGraphPipelineSessionARM"
			))
		));
	}
}

#[test]
fn create_data_graph_pipeline_session_arm_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::DataGraphPipelineSessionCreateInfoARM<'_>,
		arg_2: *const vk::AllocationCallbacks,
		arg_3: *mut vk::DataGraphPipelineSessionARM,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::DataGraphPipelineSessionCreateInfoARM<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
				) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::DataGraphPipelineSessionARM,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCreateDataGraphPipelineSessionARM = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkCreateDataGraphPipelineSessionARM,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkCreateDataGraphPipelineSessionARM", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::create_data_graph_pipeline_session_arm(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::DataGraphPipelineSessionCreateInfoARM<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::DataGraphPipelineSessionARM
				),
				expected
			);
			assert_eq!(
				vk::Device::create_data_graph_pipeline_session_arm(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::DataGraphPipelineSessionCreateInfoARM<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::DataGraphPipelineSessionARM
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_data_graph_pipeline_session_bind_point_requirements_arm_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::DataGraphPipelineSessionBindPointRequirementsInfoARM<'_>,
		*mut u32,
		*mut vk::DataGraphPipelineSessionBindPointRequirementARM<'_>,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_data_graph_pipeline_session_bind_point_requirements_arm;
	let _: Signature = vk::Device::get_data_graph_pipeline_session_bind_point_requirements_arm;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_data_graph_pipeline_session_bind_point_requirements_arm(
				&fixture.device,
				std::mem::zeroed::<*const vk::DataGraphPipelineSessionBindPointRequirementsInfoARM<'_>>(),
				std::mem::zeroed::<*mut u32>(),
				std::mem::zeroed::<*mut vk::DataGraphPipelineSessionBindPointRequirementARM<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetDataGraphPipelineSessionBindPointRequirementsARM"
			))
		));
		assert!(matches!(
			fixture
				.device
				.get_data_graph_pipeline_session_bind_point_requirements_arm(
					std::mem::zeroed::<*const vk::DataGraphPipelineSessionBindPointRequirementsInfoARM<'_>>(),
					std::mem::zeroed::<*mut u32>(),
					std::mem::zeroed::<*mut vk::DataGraphPipelineSessionBindPointRequirementARM<'_>>()
				),
			Err(CallError::MissingCommand(
				"vkGetDataGraphPipelineSessionBindPointRequirementsARM"
			))
		));
	}
}

#[test]
fn get_data_graph_pipeline_session_bind_point_requirements_arm_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::DataGraphPipelineSessionBindPointRequirementsInfoARM<'_>,
		arg_2: *mut u32,
		arg_3: *mut vk::DataGraphPipelineSessionBindPointRequirementARM<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::DataGraphPipelineSessionBindPointRequirementsInfoARM<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut u32,
				) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::DataGraphPipelineSessionBindPointRequirementARM<'_>,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetDataGraphPipelineSessionBindPointRequirementsARM = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetDataGraphPipelineSessionBindPointRequirementsARM,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(
			c"vkGetDataGraphPipelineSessionBindPointRequirementsARM",
			erased,
		);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_data_graph_pipeline_session_bind_point_requirements_arm(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::DataGraphPipelineSessionBindPointRequirementsInfoARM<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut u32,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::DataGraphPipelineSessionBindPointRequirementARM<'_>
				),
				expected
			);
			assert_eq!(
				vk::Device::get_data_graph_pipeline_session_bind_point_requirements_arm(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::DataGraphPipelineSessionBindPointRequirementsInfoARM<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut u32,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::DataGraphPipelineSessionBindPointRequirementARM<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_data_graph_pipeline_session_memory_requirements_arm_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::DataGraphPipelineSessionMemoryRequirementsInfoARM<'_>,
		*mut vk::MemoryRequirements2<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::get_data_graph_pipeline_session_memory_requirements_arm;
	let _: Signature = vk::Device::get_data_graph_pipeline_session_memory_requirements_arm;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_data_graph_pipeline_session_memory_requirements_arm(
				&fixture.device,
				std::mem::zeroed::<*const vk::DataGraphPipelineSessionMemoryRequirementsInfoARM<'_>>(),
				std::mem::zeroed::<*mut vk::MemoryRequirements2<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetDataGraphPipelineSessionMemoryRequirementsARM"
			))
		));
		assert!(matches!(
			fixture
				.device
				.get_data_graph_pipeline_session_memory_requirements_arm(
					std::mem::zeroed::<*const vk::DataGraphPipelineSessionMemoryRequirementsInfoARM<'_>>(),
					std::mem::zeroed::<*mut vk::MemoryRequirements2<'_>>()
				),
			Err(CallError::MissingCommand(
				"vkGetDataGraphPipelineSessionMemoryRequirementsARM"
			))
		));
	}
}

#[test]
fn get_data_graph_pipeline_session_memory_requirements_arm_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::DataGraphPipelineSessionMemoryRequirementsInfoARM<'_>,
		arg_2: *mut vk::MemoryRequirements2<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::DataGraphPipelineSessionMemoryRequirementsInfoARM<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::MemoryRequirements2<'_>,
				)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetDataGraphPipelineSessionMemoryRequirementsARM = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetDataGraphPipelineSessionMemoryRequirementsARM,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(
			c"vkGetDataGraphPipelineSessionMemoryRequirementsARM",
			erased,
		);
		let resolutions = Fixture::query_count();
		vk::get_data_graph_pipeline_session_memory_requirements_arm(
			&fixture.device,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::DataGraphPipelineSessionMemoryRequirementsInfoARM<'_>,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *mut vk::MemoryRequirements2<'_>,
		)
		.unwrap();
		vk::Device::get_data_graph_pipeline_session_memory_requirements_arm(
			&fixture.device,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::DataGraphPipelineSessionMemoryRequirementsInfoARM<'_>,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *mut vk::MemoryRequirements2<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn bind_data_graph_pipeline_session_memory_arm_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		u32,
		*const vk::BindDataGraphPipelineSessionMemoryInfoARM<'_>,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::bind_data_graph_pipeline_session_memory_arm;
	let _: Signature = vk::Device::bind_data_graph_pipeline_session_memory_arm;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::bind_data_graph_pipeline_session_memory_arm(
				&fixture.device,
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::BindDataGraphPipelineSessionMemoryInfoARM<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkBindDataGraphPipelineSessionMemoryARM"
			))
		));
		assert!(matches!(
			fixture.device.bind_data_graph_pipeline_session_memory_arm(
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::BindDataGraphPipelineSessionMemoryInfoARM<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkBindDataGraphPipelineSessionMemoryARM"
			))
		));
	}
}

#[test]
fn bind_data_graph_pipeline_session_memory_arm_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: u32,
		arg_2: *const vk::BindDataGraphPipelineSessionMemoryInfoARM<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == Default::default()
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *const vk::BindDataGraphPipelineSessionMemoryInfoARM<'_>,
					)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkBindDataGraphPipelineSessionMemoryARM = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkBindDataGraphPipelineSessionMemoryARM,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkBindDataGraphPipelineSessionMemoryARM", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::bind_data_graph_pipeline_session_memory_arm(
					&fixture.device,
					Default::default(),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::BindDataGraphPipelineSessionMemoryInfoARM<'_>
				),
				expected
			);
			assert_eq!(
				vk::Device::bind_data_graph_pipeline_session_memory_arm(
					&fixture.device,
					Default::default(),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::BindDataGraphPipelineSessionMemoryInfoARM<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn destroy_data_graph_pipeline_session_arm_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::DataGraphPipelineSessionARM,
		*const vk::AllocationCallbacks,
	) -> Result<(), CallError>;
	let _: Signature = vk::destroy_data_graph_pipeline_session_arm;
	let _: Signature = vk::Device::destroy_data_graph_pipeline_session_arm;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::destroy_data_graph_pipeline_session_arm(
				&fixture.device,
				std::mem::zeroed::<vk::DataGraphPipelineSessionARM>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>()
			),
			Err(CallError::MissingCommand(
				"vkDestroyDataGraphPipelineSessionARM"
			))
		));
		assert!(matches!(
			fixture.device.destroy_data_graph_pipeline_session_arm(
				std::mem::zeroed::<vk::DataGraphPipelineSessionARM>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>()
			),
			Err(CallError::MissingCommand(
				"vkDestroyDataGraphPipelineSessionARM"
			))
		));
	}
}

#[test]
fn destroy_data_graph_pipeline_session_arm_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: vk::DataGraphPipelineSessionARM,
		arg_2: *const vk::AllocationCallbacks,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == vk::DataGraphPipelineSessionARM::from_raw(305398016_u64 as _)
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *const vk::AllocationCallbacks,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkDestroyDataGraphPipelineSessionARM = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkDestroyDataGraphPipelineSessionARM,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkDestroyDataGraphPipelineSessionARM", erased);
		let resolutions = Fixture::query_count();
		vk::destroy_data_graph_pipeline_session_arm(
			&fixture.device,
			vk::DataGraphPipelineSessionARM::from_raw(305398016_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::AllocationCallbacks,
		)
		.unwrap();
		vk::Device::destroy_data_graph_pipeline_session_arm(
			&fixture.device,
			vk::DataGraphPipelineSessionARM::from_raw(305398016_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::AllocationCallbacks,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_dispatch_data_graph_arm_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		vk::DataGraphPipelineSessionARM,
		*const vk::DataGraphPipelineDispatchInfoARM<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_dispatch_data_graph_arm;
	let _: Signature = vk::Device::cmd_dispatch_data_graph_arm;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_dispatch_data_graph_arm(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::DataGraphPipelineSessionARM>(),
				std::mem::zeroed::<*const vk::DataGraphPipelineDispatchInfoARM<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdDispatchDataGraphARM"))
		));
		assert!(matches!(
			fixture.device.cmd_dispatch_data_graph_arm(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::DataGraphPipelineSessionARM>(),
				std::mem::zeroed::<*const vk::DataGraphPipelineDispatchInfoARM<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdDispatchDataGraphARM"))
		));
	}
}

#[test]
fn cmd_dispatch_data_graph_arm_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: vk::DataGraphPipelineSessionARM,
		arg_2: *const vk::DataGraphPipelineDispatchInfoARM<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == vk::DataGraphPipelineSessionARM::from_raw(305398016_u64 as _)
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *const vk::DataGraphPipelineDispatchInfoARM<'_>,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdDispatchDataGraphARM = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdDispatchDataGraphARM, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdDispatchDataGraphARM", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_dispatch_data_graph_arm(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::DataGraphPipelineSessionARM::from_raw(305398016_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::DataGraphPipelineDispatchInfoARM<'_>,
		)
		.unwrap();
		vk::Device::cmd_dispatch_data_graph_arm(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::DataGraphPipelineSessionARM::from_raw(305398016_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *const vk::DataGraphPipelineDispatchInfoARM<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_data_graph_pipeline_available_properties_arm_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::DataGraphPipelineInfoARM<'_>,
		*mut u32,
		*mut vk::DataGraphPipelinePropertyARM,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_data_graph_pipeline_available_properties_arm;
	let _: Signature = vk::Device::get_data_graph_pipeline_available_properties_arm;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_data_graph_pipeline_available_properties_arm(
				&fixture.device,
				std::mem::zeroed::<*const vk::DataGraphPipelineInfoARM<'_>>(),
				std::mem::zeroed::<*mut u32>(),
				std::mem::zeroed::<*mut vk::DataGraphPipelinePropertyARM>()
			),
			Err(CallError::MissingCommand(
				"vkGetDataGraphPipelineAvailablePropertiesARM"
			))
		));
		assert!(matches!(
			fixture
				.device
				.get_data_graph_pipeline_available_properties_arm(
					std::mem::zeroed::<*const vk::DataGraphPipelineInfoARM<'_>>(),
					std::mem::zeroed::<*mut u32>(),
					std::mem::zeroed::<*mut vk::DataGraphPipelinePropertyARM>()
				),
			Err(CallError::MissingCommand(
				"vkGetDataGraphPipelineAvailablePropertiesARM"
			))
		));
	}
}

#[test]
fn get_data_graph_pipeline_available_properties_arm_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::DataGraphPipelineInfoARM<'_>,
		arg_2: *mut u32,
		arg_3: *mut vk::DataGraphPipelinePropertyARM,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::DataGraphPipelineInfoARM<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut u32,
				) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::DataGraphPipelinePropertyARM,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetDataGraphPipelineAvailablePropertiesARM = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetDataGraphPipelineAvailablePropertiesARM,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture =
			Fixture::new_with_command(c"vkGetDataGraphPipelineAvailablePropertiesARM", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_data_graph_pipeline_available_properties_arm(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::DataGraphPipelineInfoARM<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut u32,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::DataGraphPipelinePropertyARM
				),
				expected
			);
			assert_eq!(
				vk::Device::get_data_graph_pipeline_available_properties_arm(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::DataGraphPipelineInfoARM<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut u32,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::DataGraphPipelinePropertyARM
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_data_graph_pipeline_properties_arm_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::DataGraphPipelineInfoARM<'_>,
		u32,
		*mut vk::DataGraphPipelinePropertyQueryResultARM<'_>,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_data_graph_pipeline_properties_arm;
	let _: Signature = vk::Device::get_data_graph_pipeline_properties_arm;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_data_graph_pipeline_properties_arm(
				&fixture.device,
				std::mem::zeroed::<*const vk::DataGraphPipelineInfoARM<'_>>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*mut vk::DataGraphPipelinePropertyQueryResultARM<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetDataGraphPipelinePropertiesARM"
			))
		));
		assert!(matches!(
			fixture.device.get_data_graph_pipeline_properties_arm(
				std::mem::zeroed::<*const vk::DataGraphPipelineInfoARM<'_>>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*mut vk::DataGraphPipelinePropertyQueryResultARM<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetDataGraphPipelinePropertiesARM"
			))
		));
	}
}

#[test]
fn get_data_graph_pipeline_properties_arm_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::DataGraphPipelineInfoARM<'_>,
		arg_2: u32,
		arg_3: *mut vk::DataGraphPipelinePropertyQueryResultARM<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::DataGraphPipelineInfoARM<'_>,
					) && arg_2 == Default::default()
					&& std::ptr::eq(
						arg_3,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
							as *mut vk::DataGraphPipelinePropertyQueryResultARM<'_>,
					)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetDataGraphPipelinePropertiesARM = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetDataGraphPipelinePropertiesARM,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkGetDataGraphPipelinePropertiesARM", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_data_graph_pipeline_properties_arm(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::DataGraphPipelineInfoARM<'_>,
					Default::default(),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::DataGraphPipelinePropertyQueryResultARM<'_>
				),
				expected
			);
			assert_eq!(
				vk::Device::get_data_graph_pipeline_properties_arm(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::DataGraphPipelineInfoARM<'_>,
					Default::default(),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::DataGraphPipelinePropertyQueryResultARM<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_physical_device_queue_family_data_graph_properties_arm_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		vk::PhysicalDevice,
		u32,
		*mut u32,
		*mut vk::QueueFamilyDataGraphPropertiesARM<'_>,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_physical_device_queue_family_data_graph_properties_arm;
	let _: Signature = vk::Instance::get_physical_device_queue_family_data_graph_properties_arm;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_physical_device_queue_family_data_graph_properties_arm(
				&fixture.instance,
				std::mem::zeroed::<vk::PhysicalDevice>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*mut u32>(),
				std::mem::zeroed::<*mut vk::QueueFamilyDataGraphPropertiesARM<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM"
			))
		));
		assert!(matches!(
			fixture
				.instance
				.get_physical_device_queue_family_data_graph_properties_arm(
					std::mem::zeroed::<vk::PhysicalDevice>(),
					std::mem::zeroed::<u32>(),
					std::mem::zeroed::<*mut u32>(),
					std::mem::zeroed::<*mut vk::QueueFamilyDataGraphPropertiesARM<'_>>()
				),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM"
			))
		));
	}
}

#[test]
fn get_physical_device_queue_family_data_graph_properties_arm_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::PhysicalDevice,
		arg_1: u32,
		arg_2: *mut u32,
		arg_3: *mut vk::QueueFamilyDataGraphPropertiesARM<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::PhysicalDevice::from_raw(305397760_u64 as _)
					&& arg_1 == Default::default()
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut u32,
					) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::QueueFamilyDataGraphPropertiesARM<'_>,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(
			c"vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM",
			erased,
		);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_physical_device_queue_family_data_graph_properties_arm(
					&fixture.instance,
					vk::PhysicalDevice::from_raw(305397760_u64 as _),
					Default::default(),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut u32,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::QueueFamilyDataGraphPropertiesARM<'_>
				),
				expected
			);
			assert_eq!(
				vk::Instance::get_physical_device_queue_family_data_graph_properties_arm(
					&fixture.instance,
					vk::PhysicalDevice::from_raw(305397760_u64 as _),
					Default::default(),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut u32,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::QueueFamilyDataGraphPropertiesARM<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_physical_device_queue_family_data_graph_processing_engine_properties_arm_signature_and_missing_command()
 {
	type Signature = unsafe fn(
		&vk::Instance,
		vk::PhysicalDevice,
		*const vk::PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM<'_>,
		*mut vk::QueueFamilyDataGraphProcessingEnginePropertiesARM<'_>,
	) -> Result<(), CallError>;
	let _: Signature =
		vk::get_physical_device_queue_family_data_graph_processing_engine_properties_arm;
	let _: Signature =
		vk::Instance::get_physical_device_queue_family_data_graph_processing_engine_properties_arm;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_physical_device_queue_family_data_graph_processing_engine_properties_arm(
				&fixture.instance,
				std::mem::zeroed::<vk::PhysicalDevice>(),
				std::mem::zeroed::<*const vk::PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM<'_>>(
				),
				std::mem::zeroed::<*mut vk::QueueFamilyDataGraphProcessingEnginePropertiesARM<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM"
			))
		));
		assert!(matches!(
			fixture
				.instance
				.get_physical_device_queue_family_data_graph_processing_engine_properties_arm(
					std::mem::zeroed::<vk::PhysicalDevice>(),
					std::mem::zeroed::<
						*const vk::PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM<'_>,
					>(),
					std::mem::zeroed::<*mut vk::QueueFamilyDataGraphProcessingEnginePropertiesARM<'_>>()
				),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM"
			))
		));
	}
}

#[test]
fn get_physical_device_queue_family_data_graph_processing_engine_properties_arm_native_forwarding()
{
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::PhysicalDevice,
		arg_1: *const vk::PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM<'_>,
		arg_2: *mut vk::QueueFamilyDataGraphProcessingEnginePropertiesARM<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::PhysicalDevice::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::QueueFamilyDataGraphProcessingEnginePropertiesARM<'_>,
				)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM =
			Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(
			c"vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM",
			erased,
		);
		let resolutions = Fixture::query_count();
		vk::get_physical_device_queue_family_data_graph_processing_engine_properties_arm(
			&fixture.instance,
			vk::PhysicalDevice::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM<'_>,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *mut vk::QueueFamilyDataGraphProcessingEnginePropertiesARM<'_>,
		)
		.unwrap();
		vk::Instance::get_physical_device_queue_family_data_graph_processing_engine_properties_arm(
			&fixture.instance,
			vk::PhysicalDevice::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::PhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM<'_>,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
				as *mut vk::QueueFamilyDataGraphProcessingEnginePropertiesARM<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[cfg(feature = "platform-ohos")]
#[test]
fn get_native_buffer_properties_ohos_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::OH_NativeBuffer,
		*mut vk::NativeBufferPropertiesOHOS<'_>,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_native_buffer_properties_ohos;
	let _: Signature = vk::Device::get_native_buffer_properties_ohos;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_native_buffer_properties_ohos(
				&fixture.device,
				std::mem::zeroed::<*const vk::OH_NativeBuffer>(),
				std::mem::zeroed::<*mut vk::NativeBufferPropertiesOHOS<'_>>()
			),
			Err(CallError::MissingCommand("vkGetNativeBufferPropertiesOHOS"))
		));
		assert!(matches!(
			fixture.device.get_native_buffer_properties_ohos(
				std::mem::zeroed::<*const vk::OH_NativeBuffer>(),
				std::mem::zeroed::<*mut vk::NativeBufferPropertiesOHOS<'_>>()
			),
			Err(CallError::MissingCommand("vkGetNativeBufferPropertiesOHOS"))
		));
	}
}

#[cfg(feature = "platform-ohos")]
#[test]
fn get_native_buffer_properties_ohos_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::OH_NativeBuffer,
		arg_2: *mut vk::NativeBufferPropertiesOHOS<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::OH_NativeBuffer,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::NativeBufferPropertiesOHOS<'_>,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetNativeBufferPropertiesOHOS = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkGetNativeBufferPropertiesOHOS, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkGetNativeBufferPropertiesOHOS", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_native_buffer_properties_ohos(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::OH_NativeBuffer,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::NativeBufferPropertiesOHOS<'_>
				),
				expected
			);
			assert_eq!(
				vk::Device::get_native_buffer_properties_ohos(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::OH_NativeBuffer,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut vk::NativeBufferPropertiesOHOS<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[cfg(feature = "platform-ohos")]
#[test]
fn get_memory_native_buffer_ohos_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::MemoryGetNativeBufferInfoOHOS<'_>,
		*mut *mut vk::OH_NativeBuffer,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_memory_native_buffer_ohos;
	let _: Signature = vk::Device::get_memory_native_buffer_ohos;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_memory_native_buffer_ohos(
				&fixture.device,
				std::mem::zeroed::<*const vk::MemoryGetNativeBufferInfoOHOS<'_>>(),
				std::mem::zeroed::<*mut *mut vk::OH_NativeBuffer>()
			),
			Err(CallError::MissingCommand("vkGetMemoryNativeBufferOHOS"))
		));
		assert!(matches!(
			fixture.device.get_memory_native_buffer_ohos(
				std::mem::zeroed::<*const vk::MemoryGetNativeBufferInfoOHOS<'_>>(),
				std::mem::zeroed::<*mut *mut vk::OH_NativeBuffer>()
			),
			Err(CallError::MissingCommand("vkGetMemoryNativeBufferOHOS"))
		));
	}
}

#[cfg(feature = "platform-ohos")]
#[test]
fn get_memory_native_buffer_ohos_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::MemoryGetNativeBufferInfoOHOS<'_>,
		arg_2: *mut *mut vk::OH_NativeBuffer,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::MemoryGetNativeBufferInfoOHOS<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut *mut vk::OH_NativeBuffer,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetMemoryNativeBufferOHOS = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkGetMemoryNativeBufferOHOS, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkGetMemoryNativeBufferOHOS", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_memory_native_buffer_ohos(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::MemoryGetNativeBufferInfoOHOS<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut *mut vk::OH_NativeBuffer
				),
				expected
			);
			assert_eq!(
				vk::Device::get_memory_native_buffer_ohos(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::MemoryGetNativeBufferInfoOHOS<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *mut *mut vk::OH_NativeBuffer
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn queue_set_perf_hint_qcom_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::Queue,
		*const vk::PerfHintInfoQCOM<'_>,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::queue_set_perf_hint_qcom;
	let _: Signature = vk::Device::queue_set_perf_hint_qcom;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::queue_set_perf_hint_qcom(
				&fixture.device,
				std::mem::zeroed::<vk::Queue>(),
				std::mem::zeroed::<*const vk::PerfHintInfoQCOM<'_>>()
			),
			Err(CallError::MissingCommand("vkQueueSetPerfHintQCOM"))
		));
		assert!(matches!(
			fixture.device.queue_set_perf_hint_qcom(
				std::mem::zeroed::<vk::Queue>(),
				std::mem::zeroed::<*const vk::PerfHintInfoQCOM<'_>>()
			),
			Err(CallError::MissingCommand("vkQueueSetPerfHintQCOM"))
		));
	}
}

#[test]
fn queue_set_perf_hint_qcom_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::Queue,
		arg_1: *const vk::PerfHintInfoQCOM<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::Queue::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::PerfHintInfoQCOM<'_>,
					)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkQueueSetPerfHintQCOM = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkQueueSetPerfHintQCOM, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkQueueSetPerfHintQCOM", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::queue_set_perf_hint_qcom(
					&fixture.device,
					vk::Queue::from_raw(305397760_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::PerfHintInfoQCOM<'_>
				),
				expected
			);
			assert_eq!(
				vk::Device::queue_set_perf_hint_qcom(
					&fixture.device,
					vk::Queue::from_raw(305397760_u64 as _),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::PerfHintInfoQCOM<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn enumerate_physical_device_queue_family_performance_counters_by_region_arm_signature_and_missing_command()
 {
	type Signature = unsafe fn(
		&vk::Instance,
		vk::PhysicalDevice,
		u32,
		*mut u32,
		*mut vk::PerformanceCounterARM<'_>,
		*mut vk::PerformanceCounterDescriptionARM<'_>,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::enumerate_physical_device_queue_family_performance_counters_by_region_arm;
	let _: Signature =
		vk::Instance::enumerate_physical_device_queue_family_performance_counters_by_region_arm;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::enumerate_physical_device_queue_family_performance_counters_by_region_arm(
				&fixture.instance,
				std::mem::zeroed::<vk::PhysicalDevice>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*mut u32>(),
				std::mem::zeroed::<*mut vk::PerformanceCounterARM<'_>>(),
				std::mem::zeroed::<*mut vk::PerformanceCounterDescriptionARM<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM"
			))
		));
		assert!(matches!(
			fixture
				.instance
				.enumerate_physical_device_queue_family_performance_counters_by_region_arm(
					std::mem::zeroed::<vk::PhysicalDevice>(),
					std::mem::zeroed::<u32>(),
					std::mem::zeroed::<*mut u32>(),
					std::mem::zeroed::<*mut vk::PerformanceCounterARM<'_>>(),
					std::mem::zeroed::<*mut vk::PerformanceCounterDescriptionARM<'_>>()
				),
			Err(CallError::MissingCommand(
				"vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM"
			))
		));
	}
}

#[test]
fn enumerate_physical_device_queue_family_performance_counters_by_region_arm_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::PhysicalDevice,
		arg_1: u32,
		arg_2: *mut u32,
		arg_3: *mut vk::PerformanceCounterARM<'_>,
		arg_4: *mut vk::PerformanceCounterDescriptionARM<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::PhysicalDevice::from_raw(305397760_u64 as _)
					&& arg_1 == Default::default()
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut u32,
					) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::PerformanceCounterARM<'_>,
				) && std::ptr::eq(
					arg_4,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784)
						as *mut vk::PerformanceCounterDescriptionARM<'_>,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM =
			Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(
			c"vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM",
			erased,
		);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::enumerate_physical_device_queue_family_performance_counters_by_region_arm(
					&fixture.instance,
					vk::PhysicalDevice::from_raw(305397760_u64 as _),
					Default::default(),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut u32,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::PerformanceCounterARM<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784)
						as *mut vk::PerformanceCounterDescriptionARM<'_>
				),
				expected
			);
			assert_eq!(
				vk::Instance::enumerate_physical_device_queue_family_performance_counters_by_region_arm(
					&fixture.instance,
					vk::PhysicalDevice::from_raw(305397760_u64 as _),
					Default::default(),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *mut u32,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::PerformanceCounterARM<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784)
						as *mut vk::PerformanceCounterDescriptionARM<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_set_compute_occupancy_priority_nv_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		*const vk::ComputeOccupancyPriorityParametersNV<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_compute_occupancy_priority_nv;
	let _: Signature = vk::Device::cmd_set_compute_occupancy_priority_nv;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_compute_occupancy_priority_nv(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::ComputeOccupancyPriorityParametersNV<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkCmdSetComputeOccupancyPriorityNV"
			))
		));
		assert!(matches!(
			fixture.device.cmd_set_compute_occupancy_priority_nv(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::ComputeOccupancyPriorityParametersNV<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkCmdSetComputeOccupancyPriorityNV"
			))
		));
	}
}

#[test]
fn cmd_set_compute_occupancy_priority_nv_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: *const vk::ComputeOccupancyPriorityParametersNV<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::ComputeOccupancyPriorityParametersNV<'_>,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdSetComputeOccupancyPriorityNV = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkCmdSetComputeOccupancyPriorityNV,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdSetComputeOccupancyPriorityNV", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_set_compute_occupancy_priority_nv(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::ComputeOccupancyPriorityParametersNV<'_>,
		)
		.unwrap();
		vk::Device::cmd_set_compute_occupancy_priority_nv(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::ComputeOccupancyPriorityParametersNV<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn write_sampler_descriptors_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		u32,
		*const vk::SamplerCreateInfo<'_>,
		*const vk::HostAddressRangeEXT<'_>,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::write_sampler_descriptors_ext;
	let _: Signature = vk::Device::write_sampler_descriptors_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::write_sampler_descriptors_ext(
				&fixture.device,
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::SamplerCreateInfo<'_>>(),
				std::mem::zeroed::<*const vk::HostAddressRangeEXT<'_>>()
			),
			Err(CallError::MissingCommand("vkWriteSamplerDescriptorsEXT"))
		));
		assert!(matches!(
			fixture.device.write_sampler_descriptors_ext(
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::SamplerCreateInfo<'_>>(),
				std::mem::zeroed::<*const vk::HostAddressRangeEXT<'_>>()
			),
			Err(CallError::MissingCommand("vkWriteSamplerDescriptorsEXT"))
		));
	}
}

#[test]
fn write_sampler_descriptors_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: u32,
		arg_2: *const vk::SamplerCreateInfo<'_>,
		arg_3: *const vk::HostAddressRangeEXT<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == Default::default()
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *const vk::SamplerCreateInfo<'_>,
					) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *const vk::HostAddressRangeEXT<'_>,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkWriteSamplerDescriptorsEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkWriteSamplerDescriptorsEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkWriteSamplerDescriptorsEXT", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::write_sampler_descriptors_ext(
					&fixture.device,
					Default::default(),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::SamplerCreateInfo<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *const vk::HostAddressRangeEXT<'_>
				),
				expected
			);
			assert_eq!(
				vk::Device::write_sampler_descriptors_ext(
					&fixture.device,
					Default::default(),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::SamplerCreateInfo<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *const vk::HostAddressRangeEXT<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn write_resource_descriptors_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		u32,
		*const vk::ResourceDescriptorInfoEXT<'_>,
		*const vk::HostAddressRangeEXT<'_>,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::write_resource_descriptors_ext;
	let _: Signature = vk::Device::write_resource_descriptors_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::write_resource_descriptors_ext(
				&fixture.device,
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::ResourceDescriptorInfoEXT<'_>>(),
				std::mem::zeroed::<*const vk::HostAddressRangeEXT<'_>>()
			),
			Err(CallError::MissingCommand("vkWriteResourceDescriptorsEXT"))
		));
		assert!(matches!(
			fixture.device.write_resource_descriptors_ext(
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::ResourceDescriptorInfoEXT<'_>>(),
				std::mem::zeroed::<*const vk::HostAddressRangeEXT<'_>>()
			),
			Err(CallError::MissingCommand("vkWriteResourceDescriptorsEXT"))
		));
	}
}

#[test]
fn write_resource_descriptors_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: u32,
		arg_2: *const vk::ResourceDescriptorInfoEXT<'_>,
		arg_3: *const vk::HostAddressRangeEXT<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == Default::default()
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *const vk::ResourceDescriptorInfoEXT<'_>,
					) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *const vk::HostAddressRangeEXT<'_>,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkWriteResourceDescriptorsEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkWriteResourceDescriptorsEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkWriteResourceDescriptorsEXT", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::write_resource_descriptors_ext(
					&fixture.device,
					Default::default(),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::ResourceDescriptorInfoEXT<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *const vk::HostAddressRangeEXT<'_>
				),
				expected
			);
			assert_eq!(
				vk::Device::write_resource_descriptors_ext(
					&fixture.device,
					Default::default(),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::ResourceDescriptorInfoEXT<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *const vk::HostAddressRangeEXT<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_bind_sampler_heap_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		*const vk::BindHeapInfoEXT<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_bind_sampler_heap_ext;
	let _: Signature = vk::Device::cmd_bind_sampler_heap_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_bind_sampler_heap_ext(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::BindHeapInfoEXT<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdBindSamplerHeapEXT"))
		));
		assert!(matches!(
			fixture.device.cmd_bind_sampler_heap_ext(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::BindHeapInfoEXT<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdBindSamplerHeapEXT"))
		));
	}
}

#[test]
fn cmd_bind_sampler_heap_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::CommandBuffer, arg_1: *const vk::BindHeapInfoEXT<'_>) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::BindHeapInfoEXT<'_>,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdBindSamplerHeapEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdBindSamplerHeapEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdBindSamplerHeapEXT", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_bind_sampler_heap_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::BindHeapInfoEXT<'_>,
		)
		.unwrap();
		vk::Device::cmd_bind_sampler_heap_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::BindHeapInfoEXT<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_bind_resource_heap_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		*const vk::BindHeapInfoEXT<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_bind_resource_heap_ext;
	let _: Signature = vk::Device::cmd_bind_resource_heap_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_bind_resource_heap_ext(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::BindHeapInfoEXT<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdBindResourceHeapEXT"))
		));
		assert!(matches!(
			fixture.device.cmd_bind_resource_heap_ext(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::BindHeapInfoEXT<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdBindResourceHeapEXT"))
		));
	}
}

#[test]
fn cmd_bind_resource_heap_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::CommandBuffer, arg_1: *const vk::BindHeapInfoEXT<'_>) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::BindHeapInfoEXT<'_>,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdBindResourceHeapEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdBindResourceHeapEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdBindResourceHeapEXT", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_bind_resource_heap_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::BindHeapInfoEXT<'_>,
		)
		.unwrap();
		vk::Device::cmd_bind_resource_heap_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::BindHeapInfoEXT<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_push_data_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		*const vk::PushDataInfoEXT<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_push_data_ext;
	let _: Signature = vk::Device::cmd_push_data_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_push_data_ext(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::PushDataInfoEXT<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdPushDataEXT"))
		));
		assert!(matches!(
			fixture.device.cmd_push_data_ext(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::PushDataInfoEXT<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdPushDataEXT"))
		));
	}
}

#[test]
fn cmd_push_data_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::CommandBuffer, arg_1: *const vk::PushDataInfoEXT<'_>) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::PushDataInfoEXT<'_>,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdPushDataEXT = Some(mock);
		let erased = std::mem::transmute::<vk::PFN_vkCmdPushDataEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdPushDataEXT", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_push_data_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::PushDataInfoEXT<'_>,
		)
		.unwrap();
		vk::Device::cmd_push_data_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::PushDataInfoEXT<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn register_custom_border_color_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::SamplerCustomBorderColorCreateInfoEXT<'_>,
		vk::Bool32,
		*mut u32,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::register_custom_border_color_ext;
	let _: Signature = vk::Device::register_custom_border_color_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::register_custom_border_color_ext(
				&fixture.device,
				std::mem::zeroed::<*const vk::SamplerCustomBorderColorCreateInfoEXT<'_>>(),
				std::mem::zeroed::<vk::Bool32>(),
				std::mem::zeroed::<*mut u32>()
			),
			Err(CallError::MissingCommand("vkRegisterCustomBorderColorEXT"))
		));
		assert!(matches!(
			fixture.device.register_custom_border_color_ext(
				std::mem::zeroed::<*const vk::SamplerCustomBorderColorCreateInfoEXT<'_>>(),
				std::mem::zeroed::<vk::Bool32>(),
				std::mem::zeroed::<*mut u32>()
			),
			Err(CallError::MissingCommand("vkRegisterCustomBorderColorEXT"))
		));
	}
}

#[test]
fn register_custom_border_color_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::SamplerCustomBorderColorCreateInfoEXT<'_>,
		arg_2: vk::Bool32,
		arg_3: *mut u32,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::SamplerCustomBorderColorCreateInfoEXT<'_>,
					) && arg_2 == 305398272_u64 as vk::Bool32
					&& std::ptr::eq(
						arg_3,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut u32,
					)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkRegisterCustomBorderColorEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkRegisterCustomBorderColorEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkRegisterCustomBorderColorEXT", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::register_custom_border_color_ext(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::SamplerCustomBorderColorCreateInfoEXT<'_>,
					305398272_u64 as vk::Bool32,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut u32
				),
				expected
			);
			assert_eq!(
				vk::Device::register_custom_border_color_ext(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::SamplerCustomBorderColorCreateInfoEXT<'_>,
					305398272_u64 as vk::Bool32,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528) as *mut u32
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn unregister_custom_border_color_ext_signature_and_missing_command() {
	type Signature = unsafe fn(&vk::Device, u32) -> Result<(), CallError>;
	let _: Signature = vk::unregister_custom_border_color_ext;
	let _: Signature = vk::Device::unregister_custom_border_color_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::unregister_custom_border_color_ext(&fixture.device, std::mem::zeroed::<u32>()),
			Err(CallError::MissingCommand(
				"vkUnregisterCustomBorderColorEXT"
			))
		));
		assert!(matches!(
			fixture
				.device
				.unregister_custom_border_color_ext(std::mem::zeroed::<u32>()),
			Err(CallError::MissingCommand(
				"vkUnregisterCustomBorderColorEXT"
			))
		));
	}
}

#[test]
fn unregister_custom_border_color_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(arg_0: vk::DeviceHandle, arg_1: u32) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get() && (arg_0 == vk::DeviceHandle::from_raw(0x2000) && arg_1 == Default::default()),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkUnregisterCustomBorderColorEXT = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkUnregisterCustomBorderColorEXT,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkUnregisterCustomBorderColorEXT", erased);
		let resolutions = Fixture::query_count();
		vk::unregister_custom_border_color_ext(&fixture.device, Default::default()).unwrap();
		vk::Device::unregister_custom_border_color_ext(&fixture.device, Default::default()).unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_image_opaque_capture_data_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		u32,
		*const vk::Image,
		*mut vk::HostAddressRangeEXT<'_>,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_image_opaque_capture_data_ext;
	let _: Signature = vk::Device::get_image_opaque_capture_data_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_image_opaque_capture_data_ext(
				&fixture.device,
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::Image>(),
				std::mem::zeroed::<*mut vk::HostAddressRangeEXT<'_>>()
			),
			Err(CallError::MissingCommand("vkGetImageOpaqueCaptureDataEXT"))
		));
		assert!(matches!(
			fixture.device.get_image_opaque_capture_data_ext(
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::Image>(),
				std::mem::zeroed::<*mut vk::HostAddressRangeEXT<'_>>()
			),
			Err(CallError::MissingCommand("vkGetImageOpaqueCaptureDataEXT"))
		));
	}
}

#[test]
fn get_image_opaque_capture_data_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: u32,
		arg_2: *const vk::Image,
		arg_3: *mut vk::HostAddressRangeEXT<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == Default::default()
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *const vk::Image,
					) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::HostAddressRangeEXT<'_>,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetImageOpaqueCaptureDataEXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkGetImageOpaqueCaptureDataEXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkGetImageOpaqueCaptureDataEXT", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_image_opaque_capture_data_ext(
					&fixture.device,
					Default::default(),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *const vk::Image,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::HostAddressRangeEXT<'_>
				),
				expected
			);
			assert_eq!(
				vk::Device::get_image_opaque_capture_data_ext(
					&fixture.device,
					Default::default(),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *const vk::Image,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::HostAddressRangeEXT<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_physical_device_descriptor_size_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Instance,
		vk::PhysicalDevice,
		vk::DescriptorType,
	) -> Result<vk::DeviceSize, CallError>;
	let _: Signature = vk::get_physical_device_descriptor_size_ext;
	let _: Signature = vk::Instance::get_physical_device_descriptor_size_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_physical_device_descriptor_size_ext(
				&fixture.instance,
				std::mem::zeroed::<vk::PhysicalDevice>(),
				std::mem::zeroed::<vk::DescriptorType>()
			),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceDescriptorSizeEXT"
			))
		));
		assert!(matches!(
			fixture.instance.get_physical_device_descriptor_size_ext(
				std::mem::zeroed::<vk::PhysicalDevice>(),
				std::mem::zeroed::<vk::DescriptorType>()
			),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceDescriptorSizeEXT"
			))
		));
	}
}

#[test]
fn get_physical_device_descriptor_size_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::PhysicalDevice,
		arg_1: vk::DescriptorType,
	) -> vk::DeviceSize {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::PhysicalDevice::from_raw(305397760_u64 as _)
					&& arg_1 == vk::DescriptorType::from_raw(305398016_u64 as _)),
		);
		0xfedc_ba98_7654_3210_u64 as vk::DeviceSize
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetPhysicalDeviceDescriptorSizeEXT = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetPhysicalDeviceDescriptorSizeEXT,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkGetPhysicalDeviceDescriptorSizeEXT", erased);
		let resolutions = Fixture::query_count();
		assert_eq!(
			vk::get_physical_device_descriptor_size_ext(
				&fixture.instance,
				vk::PhysicalDevice::from_raw(305397760_u64 as _),
				vk::DescriptorType::from_raw(305398016_u64 as _)
			)
			.unwrap(),
			0xfedc_ba98_7654_3210_u64 as vk::DeviceSize
		);
		assert_eq!(
			vk::Instance::get_physical_device_descriptor_size_ext(
				&fixture.instance,
				vk::PhysicalDevice::from_raw(305397760_u64 as _),
				vk::DescriptorType::from_raw(305398016_u64 as _)
			)
			.unwrap(),
			0xfedc_ba98_7654_3210_u64 as vk::DeviceSize
		);
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_tensor_opaque_capture_data_arm_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		u32,
		*const vk::TensorARM,
		*mut vk::HostAddressRangeEXT<'_>,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_tensor_opaque_capture_data_arm;
	let _: Signature = vk::Device::get_tensor_opaque_capture_data_arm;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_tensor_opaque_capture_data_arm(
				&fixture.device,
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::TensorARM>(),
				std::mem::zeroed::<*mut vk::HostAddressRangeEXT<'_>>()
			),
			Err(CallError::MissingCommand("vkGetTensorOpaqueCaptureDataARM"))
		));
		assert!(matches!(
			fixture.device.get_tensor_opaque_capture_data_arm(
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::TensorARM>(),
				std::mem::zeroed::<*mut vk::HostAddressRangeEXT<'_>>()
			),
			Err(CallError::MissingCommand("vkGetTensorOpaqueCaptureDataARM"))
		));
	}
}

#[test]
fn get_tensor_opaque_capture_data_arm_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: u32,
		arg_2: *const vk::TensorARM,
		arg_3: *mut vk::HostAddressRangeEXT<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& arg_1 == Default::default()
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *const vk::TensorARM,
					) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::HostAddressRangeEXT<'_>,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetTensorOpaqueCaptureDataARM = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkGetTensorOpaqueCaptureDataARM, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkGetTensorOpaqueCaptureDataARM", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_tensor_opaque_capture_data_arm(
					&fixture.device,
					Default::default(),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *const vk::TensorARM,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::HostAddressRangeEXT<'_>
				),
				expected
			);
			assert_eq!(
				vk::Device::get_tensor_opaque_capture_data_arm(
					&fixture.device,
					Default::default(),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272) as *const vk::TensorARM,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::HostAddressRangeEXT<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_copy_memory_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		*const vk::CopyDeviceMemoryInfoKHR<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_copy_memory_khr;
	let _: Signature = vk::Device::cmd_copy_memory_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_copy_memory_khr(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::CopyDeviceMemoryInfoKHR<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdCopyMemoryKHR"))
		));
		assert!(matches!(
			fixture.device.cmd_copy_memory_khr(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::CopyDeviceMemoryInfoKHR<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdCopyMemoryKHR"))
		));
	}
}

#[test]
fn cmd_copy_memory_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: *const vk::CopyDeviceMemoryInfoKHR<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::CopyDeviceMemoryInfoKHR<'_>,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdCopyMemoryKHR = Some(mock);
		let erased = std::mem::transmute::<vk::PFN_vkCmdCopyMemoryKHR, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdCopyMemoryKHR", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_copy_memory_khr(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::CopyDeviceMemoryInfoKHR<'_>,
		)
		.unwrap();
		vk::Device::cmd_copy_memory_khr(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::CopyDeviceMemoryInfoKHR<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_copy_memory_to_image_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		*const vk::CopyDeviceMemoryImageInfoKHR<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_copy_memory_to_image_khr;
	let _: Signature = vk::Device::cmd_copy_memory_to_image_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_copy_memory_to_image_khr(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::CopyDeviceMemoryImageInfoKHR<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdCopyMemoryToImageKHR"))
		));
		assert!(matches!(
			fixture.device.cmd_copy_memory_to_image_khr(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::CopyDeviceMemoryImageInfoKHR<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdCopyMemoryToImageKHR"))
		));
	}
}

#[test]
fn cmd_copy_memory_to_image_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: *const vk::CopyDeviceMemoryImageInfoKHR<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::CopyDeviceMemoryImageInfoKHR<'_>,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdCopyMemoryToImageKHR = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdCopyMemoryToImageKHR, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdCopyMemoryToImageKHR", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_copy_memory_to_image_khr(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::CopyDeviceMemoryImageInfoKHR<'_>,
		)
		.unwrap();
		vk::Device::cmd_copy_memory_to_image_khr(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::CopyDeviceMemoryImageInfoKHR<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_copy_image_to_memory_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		*const vk::CopyDeviceMemoryImageInfoKHR<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_copy_image_to_memory_khr;
	let _: Signature = vk::Device::cmd_copy_image_to_memory_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_copy_image_to_memory_khr(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::CopyDeviceMemoryImageInfoKHR<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdCopyImageToMemoryKHR"))
		));
		assert!(matches!(
			fixture.device.cmd_copy_image_to_memory_khr(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::CopyDeviceMemoryImageInfoKHR<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdCopyImageToMemoryKHR"))
		));
	}
}

#[test]
fn cmd_copy_image_to_memory_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: *const vk::CopyDeviceMemoryImageInfoKHR<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::CopyDeviceMemoryImageInfoKHR<'_>,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdCopyImageToMemoryKHR = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdCopyImageToMemoryKHR, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdCopyImageToMemoryKHR", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_copy_image_to_memory_khr(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::CopyDeviceMemoryImageInfoKHR<'_>,
		)
		.unwrap();
		vk::Device::cmd_copy_image_to_memory_khr(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::CopyDeviceMemoryImageInfoKHR<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_update_memory_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		*const vk::DeviceAddressRangeKHR,
		vk::AddressCommandFlagsKHR,
		vk::DeviceSize,
		*const std::ffi::c_void,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_update_memory_khr;
	let _: Signature = vk::Device::cmd_update_memory_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_update_memory_khr(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::DeviceAddressRangeKHR>(),
				std::mem::zeroed::<vk::AddressCommandFlagsKHR>(),
				std::mem::zeroed::<vk::DeviceSize>(),
				std::mem::zeroed::<*const std::ffi::c_void>()
			),
			Err(CallError::MissingCommand("vkCmdUpdateMemoryKHR"))
		));
		assert!(matches!(
			fixture.device.cmd_update_memory_khr(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::DeviceAddressRangeKHR>(),
				std::mem::zeroed::<vk::AddressCommandFlagsKHR>(),
				std::mem::zeroed::<vk::DeviceSize>(),
				std::mem::zeroed::<*const std::ffi::c_void>()
			),
			Err(CallError::MissingCommand("vkCmdUpdateMemoryKHR"))
		));
	}
}

#[test]
fn cmd_update_memory_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: *const vk::DeviceAddressRangeKHR,
		arg_2: vk::AddressCommandFlagsKHR,
		arg_3: vk::DeviceSize,
		arg_4: *const std::ffi::c_void,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::DeviceAddressRangeKHR,
					) && arg_2 == vk::AddressCommandFlagsKHR::from_raw(305398272_u64 as _)
					&& arg_3 == 305398528_u64 as vk::DeviceSize
					&& std::ptr::eq(
						arg_4,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784)
							as *const std::ffi::c_void,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdUpdateMemoryKHR = Some(mock);
		let erased = std::mem::transmute::<vk::PFN_vkCmdUpdateMemoryKHR, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdUpdateMemoryKHR", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_update_memory_khr(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::DeviceAddressRangeKHR,
			vk::AddressCommandFlagsKHR::from_raw(305398272_u64 as _),
			305398528_u64 as vk::DeviceSize,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784) as *const std::ffi::c_void,
		)
		.unwrap();
		vk::Device::cmd_update_memory_khr(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::DeviceAddressRangeKHR,
			vk::AddressCommandFlagsKHR::from_raw(305398272_u64 as _),
			305398528_u64 as vk::DeviceSize,
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784) as *const std::ffi::c_void,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_fill_memory_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		*const vk::DeviceAddressRangeKHR,
		vk::AddressCommandFlagsKHR,
		u32,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_fill_memory_khr;
	let _: Signature = vk::Device::cmd_fill_memory_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_fill_memory_khr(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::DeviceAddressRangeKHR>(),
				std::mem::zeroed::<vk::AddressCommandFlagsKHR>(),
				std::mem::zeroed::<u32>()
			),
			Err(CallError::MissingCommand("vkCmdFillMemoryKHR"))
		));
		assert!(matches!(
			fixture.device.cmd_fill_memory_khr(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::DeviceAddressRangeKHR>(),
				std::mem::zeroed::<vk::AddressCommandFlagsKHR>(),
				std::mem::zeroed::<u32>()
			),
			Err(CallError::MissingCommand("vkCmdFillMemoryKHR"))
		));
	}
}

#[test]
fn cmd_fill_memory_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: *const vk::DeviceAddressRangeKHR,
		arg_2: vk::AddressCommandFlagsKHR,
		arg_3: u32,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::DeviceAddressRangeKHR,
					) && arg_2 == vk::AddressCommandFlagsKHR::from_raw(305398272_u64 as _)
					&& arg_3 == Default::default()),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdFillMemoryKHR = Some(mock);
		let erased = std::mem::transmute::<vk::PFN_vkCmdFillMemoryKHR, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdFillMemoryKHR", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_fill_memory_khr(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::DeviceAddressRangeKHR,
			vk::AddressCommandFlagsKHR::from_raw(305398272_u64 as _),
			Default::default(),
		)
		.unwrap();
		vk::Device::cmd_fill_memory_khr(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::DeviceAddressRangeKHR,
			vk::AddressCommandFlagsKHR::from_raw(305398272_u64 as _),
			Default::default(),
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_copy_query_pool_results_to_memory_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		vk::QueryPool,
		u32,
		u32,
		*const vk::StridedDeviceAddressRangeKHR,
		vk::AddressCommandFlagsKHR,
		vk::QueryResultFlags,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_copy_query_pool_results_to_memory_khr;
	let _: Signature = vk::Device::cmd_copy_query_pool_results_to_memory_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_copy_query_pool_results_to_memory_khr(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::QueryPool>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::StridedDeviceAddressRangeKHR>(),
				std::mem::zeroed::<vk::AddressCommandFlagsKHR>(),
				std::mem::zeroed::<vk::QueryResultFlags>()
			),
			Err(CallError::MissingCommand(
				"vkCmdCopyQueryPoolResultsToMemoryKHR"
			))
		));
		assert!(matches!(
			fixture.device.cmd_copy_query_pool_results_to_memory_khr(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<vk::QueryPool>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::StridedDeviceAddressRangeKHR>(),
				std::mem::zeroed::<vk::AddressCommandFlagsKHR>(),
				std::mem::zeroed::<vk::QueryResultFlags>()
			),
			Err(CallError::MissingCommand(
				"vkCmdCopyQueryPoolResultsToMemoryKHR"
			))
		));
	}
}

#[test]
fn cmd_copy_query_pool_results_to_memory_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: vk::QueryPool,
		arg_2: u32,
		arg_3: u32,
		arg_4: *const vk::StridedDeviceAddressRangeKHR,
		arg_5: vk::AddressCommandFlagsKHR,
		arg_6: vk::QueryResultFlags,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == vk::QueryPool::from_raw(305398016_u64 as _)
					&& arg_2 == Default::default()
					&& arg_3 == Default::default()
					&& std::ptr::eq(
						arg_4,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784)
							as *const vk::StridedDeviceAddressRangeKHR,
					) && arg_5 == vk::AddressCommandFlagsKHR::from_raw(305399040_u64 as _)
					&& arg_6 == vk::QueryResultFlags::from_raw(305399296_u64 as _)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdCopyQueryPoolResultsToMemoryKHR = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkCmdCopyQueryPoolResultsToMemoryKHR,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdCopyQueryPoolResultsToMemoryKHR", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_copy_query_pool_results_to_memory_khr(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::QueryPool::from_raw(305398016_u64 as _),
			Default::default(),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784)
				as *const vk::StridedDeviceAddressRangeKHR,
			vk::AddressCommandFlagsKHR::from_raw(305399040_u64 as _),
			vk::QueryResultFlags::from_raw(305399296_u64 as _),
		)
		.unwrap();
		vk::Device::cmd_copy_query_pool_results_to_memory_khr(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			vk::QueryPool::from_raw(305398016_u64 as _),
			Default::default(),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784)
				as *const vk::StridedDeviceAddressRangeKHR,
			vk::AddressCommandFlagsKHR::from_raw(305399040_u64 as _),
			vk::QueryResultFlags::from_raw(305399296_u64 as _),
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_begin_conditional_rendering2_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		*const vk::ConditionalRenderingBeginInfo2EXT<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_begin_conditional_rendering2_ext;
	let _: Signature = vk::Device::cmd_begin_conditional_rendering2_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_begin_conditional_rendering2_ext(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::ConditionalRenderingBeginInfo2EXT<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkCmdBeginConditionalRendering2EXT"
			))
		));
		assert!(matches!(
			fixture.device.cmd_begin_conditional_rendering2_ext(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::ConditionalRenderingBeginInfo2EXT<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkCmdBeginConditionalRendering2EXT"
			))
		));
	}
}

#[test]
fn cmd_begin_conditional_rendering2_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: *const vk::ConditionalRenderingBeginInfo2EXT<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::ConditionalRenderingBeginInfo2EXT<'_>,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdBeginConditionalRendering2EXT = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkCmdBeginConditionalRendering2EXT,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdBeginConditionalRendering2EXT", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_begin_conditional_rendering2_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::ConditionalRenderingBeginInfo2EXT<'_>,
		)
		.unwrap();
		vk::Device::cmd_begin_conditional_rendering2_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::ConditionalRenderingBeginInfo2EXT<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_bind_transform_feedback_buffers2_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		u32,
		u32,
		*const vk::BindTransformFeedbackBuffer2InfoEXT<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_bind_transform_feedback_buffers2_ext;
	let _: Signature = vk::Device::cmd_bind_transform_feedback_buffers2_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_bind_transform_feedback_buffers2_ext(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::BindTransformFeedbackBuffer2InfoEXT<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkCmdBindTransformFeedbackBuffers2EXT"
			))
		));
		assert!(matches!(
			fixture.device.cmd_bind_transform_feedback_buffers2_ext(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::BindTransformFeedbackBuffer2InfoEXT<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkCmdBindTransformFeedbackBuffers2EXT"
			))
		));
	}
}

#[test]
fn cmd_bind_transform_feedback_buffers2_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: u32,
		arg_2: u32,
		arg_3: *const vk::BindTransformFeedbackBuffer2InfoEXT<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == Default::default()
					&& arg_2 == Default::default()
					&& std::ptr::eq(
						arg_3,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
							as *const vk::BindTransformFeedbackBuffer2InfoEXT<'_>,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdBindTransformFeedbackBuffers2EXT = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkCmdBindTransformFeedbackBuffers2EXT,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdBindTransformFeedbackBuffers2EXT", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_bind_transform_feedback_buffers2_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
				as *const vk::BindTransformFeedbackBuffer2InfoEXT<'_>,
		)
		.unwrap();
		vk::Device::cmd_bind_transform_feedback_buffers2_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
				as *const vk::BindTransformFeedbackBuffer2InfoEXT<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_begin_transform_feedback2_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		u32,
		u32,
		*const vk::BindTransformFeedbackBuffer2InfoEXT<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_begin_transform_feedback2_ext;
	let _: Signature = vk::Device::cmd_begin_transform_feedback2_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_begin_transform_feedback2_ext(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::BindTransformFeedbackBuffer2InfoEXT<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdBeginTransformFeedback2EXT"))
		));
		assert!(matches!(
			fixture.device.cmd_begin_transform_feedback2_ext(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::BindTransformFeedbackBuffer2InfoEXT<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdBeginTransformFeedback2EXT"))
		));
	}
}

#[test]
fn cmd_begin_transform_feedback2_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: u32,
		arg_2: u32,
		arg_3: *const vk::BindTransformFeedbackBuffer2InfoEXT<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == Default::default()
					&& arg_2 == Default::default()
					&& std::ptr::eq(
						arg_3,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
							as *const vk::BindTransformFeedbackBuffer2InfoEXT<'_>,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdBeginTransformFeedback2EXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdBeginTransformFeedback2EXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdBeginTransformFeedback2EXT", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_begin_transform_feedback2_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
				as *const vk::BindTransformFeedbackBuffer2InfoEXT<'_>,
		)
		.unwrap();
		vk::Device::cmd_begin_transform_feedback2_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
				as *const vk::BindTransformFeedbackBuffer2InfoEXT<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_end_transform_feedback2_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		u32,
		u32,
		*const vk::BindTransformFeedbackBuffer2InfoEXT<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_end_transform_feedback2_ext;
	let _: Signature = vk::Device::cmd_end_transform_feedback2_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_end_transform_feedback2_ext(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::BindTransformFeedbackBuffer2InfoEXT<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdEndTransformFeedback2EXT"))
		));
		assert!(matches!(
			fixture.device.cmd_end_transform_feedback2_ext(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::BindTransformFeedbackBuffer2InfoEXT<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdEndTransformFeedback2EXT"))
		));
	}
}

#[test]
fn cmd_end_transform_feedback2_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: u32,
		arg_2: u32,
		arg_3: *const vk::BindTransformFeedbackBuffer2InfoEXT<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == Default::default()
					&& arg_2 == Default::default()
					&& std::ptr::eq(
						arg_3,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
							as *const vk::BindTransformFeedbackBuffer2InfoEXT<'_>,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdEndTransformFeedback2EXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdEndTransformFeedback2EXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdEndTransformFeedback2EXT", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_end_transform_feedback2_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
				as *const vk::BindTransformFeedbackBuffer2InfoEXT<'_>,
		)
		.unwrap();
		vk::Device::cmd_end_transform_feedback2_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
				as *const vk::BindTransformFeedbackBuffer2InfoEXT<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_draw_indirect_byte_count2_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		u32,
		u32,
		*const vk::BindTransformFeedbackBuffer2InfoEXT<'_>,
		u32,
		u32,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_draw_indirect_byte_count2_ext;
	let _: Signature = vk::Device::cmd_draw_indirect_byte_count2_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_draw_indirect_byte_count2_ext(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::BindTransformFeedbackBuffer2InfoEXT<'_>>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>()
			),
			Err(CallError::MissingCommand("vkCmdDrawIndirectByteCount2EXT"))
		));
		assert!(matches!(
			fixture.device.cmd_draw_indirect_byte_count2_ext(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::BindTransformFeedbackBuffer2InfoEXT<'_>>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>()
			),
			Err(CallError::MissingCommand("vkCmdDrawIndirectByteCount2EXT"))
		));
	}
}

#[test]
fn cmd_draw_indirect_byte_count2_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: u32,
		arg_2: u32,
		arg_3: *const vk::BindTransformFeedbackBuffer2InfoEXT<'_>,
		arg_4: u32,
		arg_5: u32,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == Default::default()
					&& arg_2 == Default::default()
					&& std::ptr::eq(
						arg_3,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
							as *const vk::BindTransformFeedbackBuffer2InfoEXT<'_>,
					) && arg_4 == Default::default()
					&& arg_5 == Default::default()),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdDrawIndirectByteCount2EXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdDrawIndirectByteCount2EXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdDrawIndirectByteCount2EXT", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_draw_indirect_byte_count2_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
				as *const vk::BindTransformFeedbackBuffer2InfoEXT<'_>,
			Default::default(),
			Default::default(),
		)
		.unwrap();
		vk::Device::cmd_draw_indirect_byte_count2_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
				as *const vk::BindTransformFeedbackBuffer2InfoEXT<'_>,
			Default::default(),
			Default::default(),
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_write_marker_to_memory_amd_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		*const vk::MemoryMarkerInfoAMD<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_write_marker_to_memory_amd;
	let _: Signature = vk::Device::cmd_write_marker_to_memory_amd;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_write_marker_to_memory_amd(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::MemoryMarkerInfoAMD<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdWriteMarkerToMemoryAMD"))
		));
		assert!(matches!(
			fixture.device.cmd_write_marker_to_memory_amd(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::MemoryMarkerInfoAMD<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdWriteMarkerToMemoryAMD"))
		));
	}
}

#[test]
fn cmd_write_marker_to_memory_amd_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: *const vk::MemoryMarkerInfoAMD<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::MemoryMarkerInfoAMD<'_>,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdWriteMarkerToMemoryAMD = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdWriteMarkerToMemoryAMD, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdWriteMarkerToMemoryAMD", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_write_marker_to_memory_amd(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::MemoryMarkerInfoAMD<'_>,
		)
		.unwrap();
		vk::Device::cmd_write_marker_to_memory_amd(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::MemoryMarkerInfoAMD<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_bind_index_buffer3_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		*const vk::BindIndexBuffer3InfoKHR<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_bind_index_buffer3_khr;
	let _: Signature = vk::Device::cmd_bind_index_buffer3_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_bind_index_buffer3_khr(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::BindIndexBuffer3InfoKHR<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdBindIndexBuffer3KHR"))
		));
		assert!(matches!(
			fixture.device.cmd_bind_index_buffer3_khr(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::BindIndexBuffer3InfoKHR<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdBindIndexBuffer3KHR"))
		));
	}
}

#[test]
fn cmd_bind_index_buffer3_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: *const vk::BindIndexBuffer3InfoKHR<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::BindIndexBuffer3InfoKHR<'_>,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdBindIndexBuffer3KHR = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdBindIndexBuffer3KHR, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdBindIndexBuffer3KHR", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_bind_index_buffer3_khr(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::BindIndexBuffer3InfoKHR<'_>,
		)
		.unwrap();
		vk::Device::cmd_bind_index_buffer3_khr(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::BindIndexBuffer3InfoKHR<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_bind_vertex_buffers3_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		u32,
		u32,
		*const vk::BindVertexBuffer3InfoKHR<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_bind_vertex_buffers3_khr;
	let _: Signature = vk::Device::cmd_bind_vertex_buffers3_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_bind_vertex_buffers3_khr(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::BindVertexBuffer3InfoKHR<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdBindVertexBuffers3KHR"))
		));
		assert!(matches!(
			fixture.device.cmd_bind_vertex_buffers3_khr(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::BindVertexBuffer3InfoKHR<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdBindVertexBuffers3KHR"))
		));
	}
}

#[test]
fn cmd_bind_vertex_buffers3_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: u32,
		arg_2: u32,
		arg_3: *const vk::BindVertexBuffer3InfoKHR<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& arg_1 == Default::default()
					&& arg_2 == Default::default()
					&& std::ptr::eq(
						arg_3,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
							as *const vk::BindVertexBuffer3InfoKHR<'_>,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdBindVertexBuffers3KHR = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdBindVertexBuffers3KHR, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdBindVertexBuffers3KHR", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_bind_vertex_buffers3_khr(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
				as *const vk::BindVertexBuffer3InfoKHR<'_>,
		)
		.unwrap();
		vk::Device::cmd_bind_vertex_buffers3_khr(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			Default::default(),
			Default::default(),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
				as *const vk::BindVertexBuffer3InfoKHR<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_draw_indirect2_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		*const vk::DrawIndirect2InfoKHR<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_draw_indirect2_khr;
	let _: Signature = vk::Device::cmd_draw_indirect2_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_draw_indirect2_khr(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::DrawIndirect2InfoKHR<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdDrawIndirect2KHR"))
		));
		assert!(matches!(
			fixture.device.cmd_draw_indirect2_khr(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::DrawIndirect2InfoKHR<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdDrawIndirect2KHR"))
		));
	}
}

#[test]
fn cmd_draw_indirect2_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: *const vk::DrawIndirect2InfoKHR<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::DrawIndirect2InfoKHR<'_>,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdDrawIndirect2KHR = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdDrawIndirect2KHR, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdDrawIndirect2KHR", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_draw_indirect2_khr(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::DrawIndirect2InfoKHR<'_>,
		)
		.unwrap();
		vk::Device::cmd_draw_indirect2_khr(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::DrawIndirect2InfoKHR<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_draw_indexed_indirect2_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		*const vk::DrawIndirect2InfoKHR<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_draw_indexed_indirect2_khr;
	let _: Signature = vk::Device::cmd_draw_indexed_indirect2_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_draw_indexed_indirect2_khr(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::DrawIndirect2InfoKHR<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdDrawIndexedIndirect2KHR"))
		));
		assert!(matches!(
			fixture.device.cmd_draw_indexed_indirect2_khr(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::DrawIndirect2InfoKHR<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdDrawIndexedIndirect2KHR"))
		));
	}
}

#[test]
fn cmd_draw_indexed_indirect2_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: *const vk::DrawIndirect2InfoKHR<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::DrawIndirect2InfoKHR<'_>,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdDrawIndexedIndirect2KHR = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdDrawIndexedIndirect2KHR, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdDrawIndexedIndirect2KHR", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_draw_indexed_indirect2_khr(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::DrawIndirect2InfoKHR<'_>,
		)
		.unwrap();
		vk::Device::cmd_draw_indexed_indirect2_khr(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::DrawIndirect2InfoKHR<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_draw_indirect_count2_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		*const vk::DrawIndirectCount2InfoKHR<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_draw_indirect_count2_khr;
	let _: Signature = vk::Device::cmd_draw_indirect_count2_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_draw_indirect_count2_khr(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::DrawIndirectCount2InfoKHR<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdDrawIndirectCount2KHR"))
		));
		assert!(matches!(
			fixture.device.cmd_draw_indirect_count2_khr(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::DrawIndirectCount2InfoKHR<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdDrawIndirectCount2KHR"))
		));
	}
}

#[test]
fn cmd_draw_indirect_count2_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: *const vk::DrawIndirectCount2InfoKHR<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::DrawIndirectCount2InfoKHR<'_>,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdDrawIndirectCount2KHR = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdDrawIndirectCount2KHR, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdDrawIndirectCount2KHR", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_draw_indirect_count2_khr(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::DrawIndirectCount2InfoKHR<'_>,
		)
		.unwrap();
		vk::Device::cmd_draw_indirect_count2_khr(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::DrawIndirectCount2InfoKHR<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_draw_indexed_indirect_count2_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		*const vk::DrawIndirectCount2InfoKHR<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_draw_indexed_indirect_count2_khr;
	let _: Signature = vk::Device::cmd_draw_indexed_indirect_count2_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_draw_indexed_indirect_count2_khr(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::DrawIndirectCount2InfoKHR<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkCmdDrawIndexedIndirectCount2KHR"
			))
		));
		assert!(matches!(
			fixture.device.cmd_draw_indexed_indirect_count2_khr(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::DrawIndirectCount2InfoKHR<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkCmdDrawIndexedIndirectCount2KHR"
			))
		));
	}
}

#[test]
fn cmd_draw_indexed_indirect_count2_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: *const vk::DrawIndirectCount2InfoKHR<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::DrawIndirectCount2InfoKHR<'_>,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdDrawIndexedIndirectCount2KHR = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkCmdDrawIndexedIndirectCount2KHR,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdDrawIndexedIndirectCount2KHR", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_draw_indexed_indirect_count2_khr(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::DrawIndirectCount2InfoKHR<'_>,
		)
		.unwrap();
		vk::Device::cmd_draw_indexed_indirect_count2_khr(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::DrawIndirectCount2InfoKHR<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_draw_mesh_tasks_indirect2_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		*const vk::DrawIndirect2InfoKHR<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_draw_mesh_tasks_indirect2_ext;
	let _: Signature = vk::Device::cmd_draw_mesh_tasks_indirect2_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_draw_mesh_tasks_indirect2_ext(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::DrawIndirect2InfoKHR<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdDrawMeshTasksIndirect2EXT"))
		));
		assert!(matches!(
			fixture.device.cmd_draw_mesh_tasks_indirect2_ext(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::DrawIndirect2InfoKHR<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdDrawMeshTasksIndirect2EXT"))
		));
	}
}

#[test]
fn cmd_draw_mesh_tasks_indirect2_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: *const vk::DrawIndirect2InfoKHR<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::DrawIndirect2InfoKHR<'_>,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdDrawMeshTasksIndirect2EXT = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdDrawMeshTasksIndirect2EXT, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdDrawMeshTasksIndirect2EXT", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_draw_mesh_tasks_indirect2_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::DrawIndirect2InfoKHR<'_>,
		)
		.unwrap();
		vk::Device::cmd_draw_mesh_tasks_indirect2_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::DrawIndirect2InfoKHR<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_draw_mesh_tasks_indirect_count2_ext_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		*const vk::DrawIndirectCount2InfoKHR<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_draw_mesh_tasks_indirect_count2_ext;
	let _: Signature = vk::Device::cmd_draw_mesh_tasks_indirect_count2_ext;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_draw_mesh_tasks_indirect_count2_ext(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::DrawIndirectCount2InfoKHR<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkCmdDrawMeshTasksIndirectCount2EXT"
			))
		));
		assert!(matches!(
			fixture.device.cmd_draw_mesh_tasks_indirect_count2_ext(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::DrawIndirectCount2InfoKHR<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkCmdDrawMeshTasksIndirectCount2EXT"
			))
		));
	}
}

#[test]
fn cmd_draw_mesh_tasks_indirect_count2_ext_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: *const vk::DrawIndirectCount2InfoKHR<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::DrawIndirectCount2InfoKHR<'_>,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdDrawMeshTasksIndirectCount2EXT = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkCmdDrawMeshTasksIndirectCount2EXT,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdDrawMeshTasksIndirectCount2EXT", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_draw_mesh_tasks_indirect_count2_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::DrawIndirectCount2InfoKHR<'_>,
		)
		.unwrap();
		vk::Device::cmd_draw_mesh_tasks_indirect_count2_ext(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::DrawIndirectCount2InfoKHR<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_dispatch_indirect2_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		*const vk::DispatchIndirect2InfoKHR<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_dispatch_indirect2_khr;
	let _: Signature = vk::Device::cmd_dispatch_indirect2_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_dispatch_indirect2_khr(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::DispatchIndirect2InfoKHR<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdDispatchIndirect2KHR"))
		));
		assert!(matches!(
			fixture.device.cmd_dispatch_indirect2_khr(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::DispatchIndirect2InfoKHR<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdDispatchIndirect2KHR"))
		));
	}
}

#[test]
fn cmd_dispatch_indirect2_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: *const vk::DispatchIndirect2InfoKHR<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::DispatchIndirect2InfoKHR<'_>,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdDispatchIndirect2KHR = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdDispatchIndirect2KHR, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdDispatchIndirect2KHR", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_dispatch_indirect2_khr(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::DispatchIndirect2InfoKHR<'_>,
		)
		.unwrap();
		vk::Device::cmd_dispatch_indirect2_khr(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::DispatchIndirect2InfoKHR<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn create_acceleration_structure2_khr_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		*const vk::AccelerationStructureCreateInfo2KHR<'_>,
		*const vk::AllocationCallbacks,
		*mut vk::AccelerationStructureKHR,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::create_acceleration_structure2_khr;
	let _: Signature = vk::Device::create_acceleration_structure2_khr;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::create_acceleration_structure2_khr(
				&fixture.device,
				std::mem::zeroed::<*const vk::AccelerationStructureCreateInfo2KHR<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::AccelerationStructureKHR>()
			),
			Err(CallError::MissingCommand(
				"vkCreateAccelerationStructure2KHR"
			))
		));
		assert!(matches!(
			fixture.device.create_acceleration_structure2_khr(
				std::mem::zeroed::<*const vk::AccelerationStructureCreateInfo2KHR<'_>>(),
				std::mem::zeroed::<*const vk::AllocationCallbacks>(),
				std::mem::zeroed::<*mut vk::AccelerationStructureKHR>()
			),
			Err(CallError::MissingCommand(
				"vkCreateAccelerationStructure2KHR"
			))
		));
	}
}

#[test]
fn create_acceleration_structure2_khr_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::DeviceHandle,
		arg_1: *const vk::AccelerationStructureCreateInfo2KHR<'_>,
		arg_2: *const vk::AllocationCallbacks,
		arg_3: *mut vk::AccelerationStructureKHR,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::DeviceHandle::from_raw(0x2000)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::AccelerationStructureCreateInfo2KHR<'_>,
					) && std::ptr::eq(
					arg_2,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
				) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::AccelerationStructureKHR,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCreateAccelerationStructure2KHR = Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkCreateAccelerationStructure2KHR,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(c"vkCreateAccelerationStructure2KHR", erased);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::create_acceleration_structure2_khr(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::AccelerationStructureCreateInfo2KHR<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::AccelerationStructureKHR
				),
				expected
			);
			assert_eq!(
				vk::Device::create_acceleration_structure2_khr(
					&fixture.device,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
						as *const vk::AccelerationStructureCreateInfo2KHR<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::AllocationCallbacks,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::AccelerationStructureKHR
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_physical_device_queue_family_data_graph_engine_operation_properties_arm_signature_and_missing_command()
 {
	type Signature = unsafe fn(
		&vk::Instance,
		vk::PhysicalDevice,
		u32,
		*const vk::QueueFamilyDataGraphPropertiesARM<'_>,
		*mut vk::BaseOutStructure<'_>,
	) -> Result<vk::Result, CallError>;
	let _: Signature =
		vk::get_physical_device_queue_family_data_graph_engine_operation_properties_arm;
	let _: Signature =
		vk::Instance::get_physical_device_queue_family_data_graph_engine_operation_properties_arm;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_physical_device_queue_family_data_graph_engine_operation_properties_arm(
				&fixture.instance,
				std::mem::zeroed::<vk::PhysicalDevice>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::QueueFamilyDataGraphPropertiesARM<'_>>(),
				std::mem::zeroed::<*mut vk::BaseOutStructure<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceQueueFamilyDataGraphEngineOperationPropertiesARM"
			))
		));
		assert!(matches!(
			fixture
				.instance
				.get_physical_device_queue_family_data_graph_engine_operation_properties_arm(
					std::mem::zeroed::<vk::PhysicalDevice>(),
					std::mem::zeroed::<u32>(),
					std::mem::zeroed::<*const vk::QueueFamilyDataGraphPropertiesARM<'_>>(),
					std::mem::zeroed::<*mut vk::BaseOutStructure<'_>>()
				),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceQueueFamilyDataGraphEngineOperationPropertiesARM"
			))
		));
	}
}

#[test]
fn get_physical_device_queue_family_data_graph_engine_operation_properties_arm_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::PhysicalDevice,
		arg_1: u32,
		arg_2: *const vk::QueueFamilyDataGraphPropertiesARM<'_>,
		arg_3: *mut vk::BaseOutStructure<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::PhysicalDevice::from_raw(305397760_u64 as _)
					&& arg_1 == Default::default()
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *const vk::QueueFamilyDataGraphPropertiesARM<'_>,
					) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::BaseOutStructure<'_>,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetPhysicalDeviceQueueFamilyDataGraphEngineOperationPropertiesARM =
			Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetPhysicalDeviceQueueFamilyDataGraphEngineOperationPropertiesARM,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(
			c"vkGetPhysicalDeviceQueueFamilyDataGraphEngineOperationPropertiesARM",
			erased,
		);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_physical_device_queue_family_data_graph_engine_operation_properties_arm(
					&fixture.instance,
					vk::PhysicalDevice::from_raw(305397760_u64 as _),
					Default::default(),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::QueueFamilyDataGraphPropertiesARM<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::BaseOutStructure<'_>
				),
				expected
			);
			assert_eq!(
				vk::Instance::get_physical_device_queue_family_data_graph_engine_operation_properties_arm(
					&fixture.instance,
					vk::PhysicalDevice::from_raw(305397760_u64 as _),
					Default::default(),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::QueueFamilyDataGraphPropertiesARM<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *mut vk::BaseOutStructure<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn cmd_set_dispatch_parameters_arm_signature_and_missing_command() {
	type Signature = unsafe fn(
		&vk::Device,
		vk::CommandBuffer,
		*const vk::DispatchParametersARM<'_>,
	) -> Result<(), CallError>;
	let _: Signature = vk::cmd_set_dispatch_parameters_arm;
	let _: Signature = vk::Device::cmd_set_dispatch_parameters_arm;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::cmd_set_dispatch_parameters_arm(
				&fixture.device,
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::DispatchParametersARM<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdSetDispatchParametersARM"))
		));
		assert!(matches!(
			fixture.device.cmd_set_dispatch_parameters_arm(
				std::mem::zeroed::<vk::CommandBuffer>(),
				std::mem::zeroed::<*const vk::DispatchParametersARM<'_>>()
			),
			Err(CallError::MissingCommand("vkCmdSetDispatchParametersARM"))
		));
	}
}

#[test]
fn cmd_set_dispatch_parameters_arm_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::CommandBuffer,
		arg_1: *const vk::DispatchParametersARM<'_>,
	) {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::CommandBuffer::from_raw(305397760_u64 as _)
					&& std::ptr::eq(
						arg_1,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
							as *const vk::DispatchParametersARM<'_>,
					)),
		);
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkCmdSetDispatchParametersARM = Some(mock);
		let erased =
			std::mem::transmute::<vk::PFN_vkCmdSetDispatchParametersARM, vk::PFN_vkVoidFunction>(typed);
		let fixture = Fixture::new_with_command(c"vkCmdSetDispatchParametersARM", erased);
		let resolutions = Fixture::query_count();
		vk::cmd_set_dispatch_parameters_arm(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::DispatchParametersARM<'_>,
		)
		.unwrap();
		vk::Device::cmd_set_dispatch_parameters_arm(
			&fixture.device,
			vk::CommandBuffer::from_raw(305397760_u64 as _),
			std::ptr::without_provenance_mut::<std::ffi::c_void>(305398016)
				as *const vk::DispatchParametersARM<'_>,
		)
		.unwrap();
		assert_eq!(CALLS.get(), 2);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}

#[test]
fn get_physical_device_queue_family_data_graph_optical_flow_image_formats_arm_signature_and_missing_command()
 {
	type Signature = unsafe fn(
		&vk::Instance,
		vk::PhysicalDevice,
		u32,
		*const vk::QueueFamilyDataGraphPropertiesARM<'_>,
		*const vk::DataGraphOpticalFlowImageFormatInfoARM<'_>,
		*mut u32,
		*mut vk::DataGraphOpticalFlowImageFormatPropertiesARM<'_>,
	) -> Result<vk::Result, CallError>;
	let _: Signature = vk::get_physical_device_queue_family_data_graph_optical_flow_image_formats_arm;
	let _: Signature =
		vk::Instance::get_physical_device_queue_family_data_graph_optical_flow_image_formats_arm;
	let fixture = Fixture::new();
	// SAFETY: the exact-ABI mock context has no native resources; the missing PFN returns before accessing arguments. Zeroed fixtures contain only zero-valid generated ABI values and are not native create/query inputs.
	unsafe {
		assert!(matches!(
			vk::get_physical_device_queue_family_data_graph_optical_flow_image_formats_arm(
				&fixture.instance,
				std::mem::zeroed::<vk::PhysicalDevice>(),
				std::mem::zeroed::<u32>(),
				std::mem::zeroed::<*const vk::QueueFamilyDataGraphPropertiesARM<'_>>(),
				std::mem::zeroed::<*const vk::DataGraphOpticalFlowImageFormatInfoARM<'_>>(),
				std::mem::zeroed::<*mut u32>(),
				std::mem::zeroed::<*mut vk::DataGraphOpticalFlowImageFormatPropertiesARM<'_>>()
			),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM"
			))
		));
		assert!(matches!(
			fixture
				.instance
				.get_physical_device_queue_family_data_graph_optical_flow_image_formats_arm(
					std::mem::zeroed::<vk::PhysicalDevice>(),
					std::mem::zeroed::<u32>(),
					std::mem::zeroed::<*const vk::QueueFamilyDataGraphPropertiesARM<'_>>(),
					std::mem::zeroed::<*const vk::DataGraphOpticalFlowImageFormatInfoARM<'_>>(),
					std::mem::zeroed::<*mut u32>(),
					std::mem::zeroed::<*mut vk::DataGraphOpticalFlowImageFormatPropertiesARM<'_>>()
				),
			Err(CallError::MissingCommand(
				"vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM"
			))
		));
	}
}

#[test]
fn get_physical_device_queue_family_data_graph_optical_flow_image_formats_arm_native_forwarding() {
	thread_local! { static CALLS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) }; static MATCHED: std::cell::Cell<bool> = const { std::cell::Cell::new(true) }; static STATUS: std::cell::Cell<vk::Result> = const { std::cell::Cell::new(vk::Result::SUCCESS) }; }
	unsafe extern "system" fn mock(
		arg_0: vk::PhysicalDevice,
		arg_1: u32,
		arg_2: *const vk::QueueFamilyDataGraphPropertiesARM<'_>,
		arg_3: *const vk::DataGraphOpticalFlowImageFormatInfoARM<'_>,
		arg_4: *mut u32,
		arg_5: *mut vk::DataGraphOpticalFlowImageFormatPropertiesARM<'_>,
	) -> vk::Result {
		CALLS.set(CALLS.get() + 1);
		MATCHED.set(
			MATCHED.get()
				&& (arg_0 == vk::PhysicalDevice::from_raw(305397760_u64 as _)
					&& arg_1 == Default::default()
					&& std::ptr::eq(
						arg_2,
						std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
							as *const vk::QueueFamilyDataGraphPropertiesARM<'_>,
					) && std::ptr::eq(
					arg_3,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *const vk::DataGraphOpticalFlowImageFormatInfoARM<'_>,
				) && std::ptr::eq(
					arg_4,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784) as *mut u32,
				) && std::ptr::eq(
					arg_5,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305399040)
						as *mut vk::DataGraphOpticalFlowImageFormatPropertiesARM<'_>,
				)),
		);
		STATUS.get()
	}
	// SAFETY: the exact-ABI mock only compares synthetic tokens and never accesses pointers.
	unsafe {
		let typed: vk::PFN_vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM =
			Some(mock);
		let erased = std::mem::transmute::<
			vk::PFN_vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM,
			vk::PFN_vkVoidFunction,
		>(typed);
		let fixture = Fixture::new_with_command(
			c"vkGetPhysicalDeviceQueueFamilyDataGraphOpticalFlowImageFormatsARM",
			erased,
		);
		let resolutions = Fixture::query_count();
		for status in [
			vk::Result::SUCCESS,
			vk::Result::INCOMPLETE,
			vk::Result::OPERATION_DEFERRED_KHR,
			vk::Result::from_raw(i32::MAX),
			vk::Result::ERROR_DEVICE_LOST,
			vk::Result::from_raw(i32::MIN),
		] {
			STATUS.set(status);
			let expected = if status.is_err() {
				Err(CallError::Vulkan(status))
			} else {
				Ok(status)
			};
			assert_eq!(
				vk::get_physical_device_queue_family_data_graph_optical_flow_image_formats_arm(
					&fixture.instance,
					vk::PhysicalDevice::from_raw(305397760_u64 as _),
					Default::default(),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::QueueFamilyDataGraphPropertiesARM<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *const vk::DataGraphOpticalFlowImageFormatInfoARM<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784) as *mut u32,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305399040)
						as *mut vk::DataGraphOpticalFlowImageFormatPropertiesARM<'_>
				),
				expected
			);
			assert_eq!(
				vk::Instance::get_physical_device_queue_family_data_graph_optical_flow_image_formats_arm(
					&fixture.instance,
					vk::PhysicalDevice::from_raw(305397760_u64 as _),
					Default::default(),
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398272)
						as *const vk::QueueFamilyDataGraphPropertiesARM<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398528)
						as *const vk::DataGraphOpticalFlowImageFormatInfoARM<'_>,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305398784) as *mut u32,
					std::ptr::without_provenance_mut::<std::ffi::c_void>(305399040)
						as *mut vk::DataGraphOpticalFlowImageFormatPropertiesARM<'_>
				),
				expected
			);
		}
		assert_eq!(CALLS.get(), 12);
		assert!(MATCHED.get());
		assert_eq!(Fixture::query_count(), resolutions);
	}
}