def expect(self): """4. Expects an image with linear tiling and can be used as the source and destination of a transfer command.""" architecture = self.architecture device_properties = require( self.next_call_of("vkGetPhysicalDeviceProperties")) create_image, device, image = check_create_image(self, 4) info = get_image_create_info(create_image, architecture) check_destroy_image(self, device, image, device_properties) require_equal(info.sType, VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO) require_equal(info.pNext, 0) require_equal(info.flags, 0) require_equal(info.imageType, VK_IMAGE_TYPE_2D) require_equal(info.format, VK_FORMAT_R8G8B8A8_UNORM) require_equal(info.extent_width, 32) require_equal(info.extent_height, 32) require_equal(info.extent_depth, 1) require_equal(info.mipLevels, 1) require_equal(info.arrayLayers, 1) require_equal(info.samples, VK_SAMPLE_COUNT_1_BIT) require_equal(info.tiling, VK_IMAGE_TILING_LINEAR) require_equal( info.usage, VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT) require_equal(info.sharingMode, VK_SHARING_MODE_EXCLUSIVE) require_equal(info.queueFamilyIndexCount, 0) require_equal(info.pQueueFamilyIndices, 0) require_equal(info.initialLayout, VK_IMAGE_LAYOUT_UNDEFINED)
def expect(self): """Check the arguments to vkCmdCopyBufferToImage""" architecture = self.architecture copy_buffer_to_image = require( self.nth_call_of("vkCmdCopyBufferToImage", 1)) require_not_equal(0, copy_buffer_to_image.int_commandBuffer) require_not_equal(0, copy_buffer_to_image.int_srcBuffer) require_not_equal(0, copy_buffer_to_image.int_dstImage) require_equal(VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, copy_buffer_to_image.int_dstImageLayout) require_equal(1, copy_buffer_to_image.int_regionCount) require_not_equal(0, copy_buffer_to_image.hex_pRegions) buffer_image_copy = VulkanStruct( architecture, BUFFER_IMAGE_COPY, get_read_offset_function(copy_buffer_to_image, copy_buffer_to_image.hex_pRegions)) require_equal(0, buffer_image_copy.bufferOffset) require_equal(0, buffer_image_copy.bufferRowLength) require_equal(0, buffer_image_copy.bufferImageHeight) require_equal(VK_IMAGE_ASPECT_COLOR_BIT, buffer_image_copy.imageSubresource_aspectMask) require_equal(0, buffer_image_copy.imageSubresource_mipLevel) require_equal(0, buffer_image_copy.imageSubresource_baseArrayLayer) require_equal(1, buffer_image_copy.imageSubresource_layerCount) require_equal(0, buffer_image_copy.imageOffset_x) require_equal(0, buffer_image_copy.imageOffset_y) require_equal(0, buffer_image_copy.imageOffset_z) require_equal(32, buffer_image_copy.imageExtent_width) require_equal(32, buffer_image_copy.imageExtent_height) require_equal(1, buffer_image_copy.imageExtent_depth)
def check_destroy_sampler(test, device, sampler): """Checks that the next vkDestroySampler command call atom has the passed-in |device| and |sampler| handle value. """ destroy_sampler = require(test.next_call_of("vkDestroySampler")) require_equal(device, destroy_sampler.int_device) require_equal(sampler, destroy_sampler.int_sampler)
def expect(self): """1. Expects a sampler with normalized coordinates.""" architecture = self.architecture device_properties = require( self.nth_call_of("vkGetPhysicalDeviceProperties", 1)) create_sampler, device, sampler = check_create_sampler(self) info = get_sampler_create_info(create_sampler, architecture) require_equal(info.sType, VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO) require_equal(info.pNext, 0) require_equal(info.flags, 0) require_equal(info.magFilter, VK_FILTER_NEAREST) require_equal(info.minFilter, VK_FILTER_LINEAR) require_equal(info.mipmapMode, VK_SAMPLER_MIPMAP_MODE_LINEAR) require_equal(info.addressModeU, VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE) require_equal(info.addressModeV, VK_SAMPLER_ADDRESS_MODE_REPEAT) require_equal(info.addressModeW, VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER) require_equal(info.mipLodBias, -1.) require_false(info.anisotropyEnable) require_equal(info.maxAnisotropy, 1.) require_false(info.compareEnable) require_equal(info.compareOp, VK_COMPARE_OP_ALWAYS) require_equal(info.minLod, 1.) require_equal(info.maxLod, 2.) require_equal(info.borderColor, VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK) require_false(info.unnormalizedCoordinates) check_destroy_sampler(self, device, sampler)
def expect(self): """The first call to vkCmdSetLineWidth should have line width value: 1.0 """ set_line_width = require(self.nth_call_of("vkCmdSetLineWidth", 1)) require_not_equal(0, set_line_width.int_commandBuffer) require_equal(1.0, set_line_width.float_lineWidth)
def check_destroy_image(test, device, image, device_properties): """Checks the |index|'th vkDestroyImage command call atom, including the device handler value and the image handler value. """ destroy_image = require(test.next_call_of("vkDestroyImage")) require_equal(device, destroy_image.int_device) require_equal(image, destroy_image.int_image)
def expect(self): """1. Expects a normal 2D color attachement image.""" architecture = self.architecture device_properties = require( self.next_call_of("vkGetPhysicalDeviceProperties")) create_image, device, image = check_create_image(self, 1) info = get_image_create_info(create_image, architecture) check_destroy_image(self, device, image, device_properties) require_equal(info.sType, VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO) require_equal(info.pNext, 0) require_equal(info.flags, 0) require_equal(info.imageType, VK_IMAGE_TYPE_2D) require_equal(info.format, VK_FORMAT_R8G8B8A8_UNORM) require_equal(info.extent_width, 32) require_equal(info.extent_height, 32) require_equal(info.extent_depth, 1) require_equal(info.mipLevels, 1) require_equal(info.arrayLayers, 1) require_equal(info.samples, VK_SAMPLE_COUNT_1_BIT) require_equal(info.tiling, VK_IMAGE_TILING_OPTIMAL) require_equal(info.usage, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT) require_equal(info.sharingMode, VK_SHARING_MODE_EXCLUSIVE) require_equal(info.queueFamilyIndexCount, 0) require_equal(info.pQueueFamilyIndices, 0) require_equal(info.initialLayout, VK_IMAGE_LAYOUT_UNDEFINED)
def expect(self): set_blend_constants = require( self.next_call_of("vkCmdSetBlendConstants")) require_not_equal(0, set_blend_constants.int_commandBuffer) require_equal([1.25, 2.5, 5.0, 10.0], set_blend_constants.float_blendConstants)
def expect(self): num_queries = 8 get_result_num_queries = 4 result_width = 8 architecture = self.architecture get_query_result = require(self.nth_call_of("vkGetQueryPoolResults", 2)) require_not_equal(0, get_query_result.int_device) require_not_equal(0, get_query_result.int_queryPool) require_equal(num_queries - get_result_num_queries, get_query_result.int_firstQuery) require_equal(get_result_num_queries, get_query_result.int_queryCount) require_equal(result_width * get_result_num_queries, get_query_result.int_dataSize) require_not_equal(0, get_query_result.hex_pData) require_equal(result_width, get_query_result.int_stride) require_equal(VK_QUERY_RESULT_64_BIT | VK_QUERY_RESULT_WAIT_BIT, get_query_result.int_flags) require_equal(VK_SUCCESS, int(get_query_result.return_val)) result_data = VulkanStruct( architecture, [("data", ARRAY, get_result_num_queries, UINT64_T)], get_write_offset_function(get_query_result, get_query_result.hex_pData)) require_equal([0 for i in range(get_result_num_queries)], result_data.data)
def expect(self): num_queries = 4 stride = 12 architecture = self.architecture get_query_result = require(self.nth_call_of("vkGetQueryPoolResults", 3)) require_not_equal(0, get_query_result.int_device) require_not_equal(0, get_query_result.int_queryPool) require_equal(0, get_query_result.int_firstQuery) require_equal(num_queries, get_query_result.int_queryCount) require_equal(num_queries * stride, get_query_result.int_dataSize) require_not_equal(0, get_query_result.hex_pData) require_equal(stride, get_query_result.int_stride) require_equal(VK_QUERY_RESULT_PARTIAL_BIT | VK_QUERY_RESULT_WITH_AVAILABILITY_BIT, get_query_result.int_flags) require_equal(VK_SUCCESS, int(get_query_result.return_val)) result_data = VulkanStruct( architecture, [("data", ARRAY, num_queries * stride / 4, UINT32_T)], get_write_offset_function(get_query_result, get_query_result.hex_pData)) expected_data = [0, 1, 0xFFFFFFFF, 0, 1, 0xFFFFFFFF, 0, 1, 0xFFFFFFFF, 0, 1, 0xFFFFFFFF] require_equal(expected_data, result_data.data)
def expect(self): """3. Free null descriptor sets.""" device_properties = require( self.next_call_of("vkGetPhysicalDeviceProperties")) if (self.not_device(device_properties, 0x5BCE4000, NVIDIA_K2200)): free_descriptor_set = require( self.nth_call_of("vkFreeDescriptorSets", 3)) p_sets = free_descriptor_set.hex_pDescriptorSets for i in range(2): actual_set = little_endian_bytes_to_int( require( free_descriptor_set.get_read_data( p_sets + NON_DISPATCHABLE_HANDLE_SIZE * i, NON_DISPATCHABLE_HANDLE_SIZE))) require_equal(0, actual_set)
def expect(self): dispatch = require(self.next_call_of("vkCmdDispatch")) require_not_equal(0, dispatch.int_commandBuffer) require_equal(512, dispatch.int_groupCountX) require_equal(1, dispatch.int_groupCountY) require_equal(1, dispatch.int_groupCountZ)
def expect(self): """Check the arguments to vkCmdExecuteCommands""" execute_commands = require(self.nth_call_of("vkCmdExecuteCommands", 1)) require_not_equal(0, execute_commands.int_commandBuffer) require_equal(2, execute_commands.int_commandBufferCount) require_not_equal(0, execute_commands.hex_pCommandBuffers)
def expect(self): """Check the arguments and the VkMappedMemoryRange structs used in vkFlushMappedMemoryRanges(). The flushed memory starts at offset 768 and has size 256""" MAP_OFFSET = 512 FLUSH_OFFSET = MAP_OFFSET + 256 FLUSH_SIZE = 256 MEMORY_DATA = [("data", ARRAY, FLUSH_SIZE, CHAR)] EXPECTED_MEMORY_DATA = [i for i in range(FLUSH_SIZE)] architecture = self.architecture # The first and second vkMapMemory() result is managed in # VulkanApplication and is not used here, the third is the one we need # here. map_memory = require(self.nth_call_of("vkMapMemory", 3)) require_not_equal(0, map_memory.hex_ppData) # The flushed data starts at mapped offset + 256 flushed_data_ptr = little_endian_bytes_to_int( require( map_memory.get_write_data(map_memory.hex_ppData, architecture.int_integerSize))) + 256 # Check arguments flush_mapped_memory_ranges = require( self.nth_call_of("vkFlushMappedMemoryRanges", 1)) require_equal(1, flush_mapped_memory_ranges.int_memoryRangeCount) require_not_equal(0, flush_mapped_memory_ranges.hex_pMemoryRanges) # Check the memory range struct content mapped_memory_range = VulkanStruct( architecture, MAPPED_MEMORY_RANGE, get_read_offset_function( flush_mapped_memory_ranges, flush_mapped_memory_ranges.hex_pMemoryRanges)) require_equal(VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE, mapped_memory_range.sType) require_equal(0, mapped_memory_range.pNext) require_not_equal(0, mapped_memory_range.memory) require_equal(FLUSH_OFFSET, mapped_memory_range.offset) require_equal(FLUSH_SIZE, mapped_memory_range.size) # check the flushed memory data memory_data = VulkanStruct( architecture, MEMORY_DATA, get_read_offset_function(flush_mapped_memory_ranges, flushed_data_ptr)) require_equal(EXPECTED_MEMORY_DATA, memory_data.data)
def expect(self): """Expect that the applicationInfoPointer is null for the first vkCreateInstance""" if self.device.Configuration.OS.Kind != ANDROID: return architecture = self.architecture create_surface = require( self.next_call_of("vkCreateAndroidSurfaceKHR")) # Make sure the parameters are valid require_not_equal(create_surface.int_instance, 0) require_not_equal(create_surface.hex_pCreateInfo, 0) require_equal(create_surface.hex_pAllocator, 0) require_not_equal(create_surface.hex_pSurface, 0) create_surface_structure_type_memory = require( create_surface.get_read_data(create_surface.hex_pCreateInfo, architecture.int_integerSize)) create_surface_pNext_memory = require( create_surface.get_read_data(create_surface.hex_pCreateInfo + architecture.int_pointerSize, architecture.int_pointerSize)) create_surface_flags_memory = require( create_surface.get_read_data(create_surface.hex_pCreateInfo + 2 * architecture.int_pointerSize, architecture.int_integerSize)) create_surface_native_window_memory = require( create_surface.get_read_data(create_surface.hex_pCreateInfo + 3 * architecture.int_pointerSize, architecture.int_pointerSize)) # The struct should look like # {VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR, 0, 0, window} require_equal( little_endian_bytes_to_int(create_surface_structure_type_memory), VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR) require_equal( little_endian_bytes_to_int(create_surface_pNext_memory), 0) require_equal( little_endian_bytes_to_int(create_surface_flags_memory), 0) require_not_equal( little_endian_bytes_to_int(create_surface_native_window_memory), 0) # pSemaphore is filled in by the call, should be a write observation surface = require( create_surface.get_write_data(create_surface.hex_pSurface, NON_DISPATCHABLE_HANDLE_SIZE)) # We should have called destroy_semaphore with the same one destroy_surface = require(self.next_call_of("vkDestroySurfaceKHR")) require_equal( little_endian_bytes_to_int(surface), destroy_surface.int_surface) destroy_surface_2 = require(self.next_call_of("vkDestroySurfaceKHR")) require_equal(0, destroy_surface_2.int_surface)
def check_free_descriptor_set(test, device, pool, sets): """Checks that the next vkFreeDescriptorSets command call atom is used to free the given descriptor |sets| from the given descriptor |pool| on the given |device|. """ free_descriptor_set = require( test.next_call_of("vkFreeDescriptorSets")) require_equal(device, free_descriptor_set.int_device) require_equal(pool, free_descriptor_set.int_descriptorPool) require_equal(len(sets), free_descriptor_set.int_descriptorSetCount) p_sets = free_descriptor_set.hex_pDescriptorSets for i, expected_set in enumerate(sets): actual_set = little_endian_bytes_to_int( require(free_descriptor_set.get_read_data( p_sets + NON_DISPATCHABLE_HANDLE_SIZE * i, NON_DISPATCHABLE_HANDLE_SIZE))) require_equal(expected_set, actual_set)
def get_descriptor_set_alloc_info(alloc_descriptor_set, architecture): """Returns a VulkanStruct representing the VkDescriptorSetAllocateInfo struct used in the given |alloc_descriptor_set| command.""" return VulkanStruct( architecture, DESCRIPTOR_SET_ALLOCATE_INFO_ELEMENTS, lambda offset, size: little_endian_bytes_to_int(require( alloc_descriptor_set.get_read_data( alloc_descriptor_set.hex_pAllocateInfo + offset, size))))
def expect(self): architecture = self.architecture bind_pipeline = require(self.next_call_of("vkCmdBindPipeline")) require_not_equal(0, bind_pipeline.int_commandBuffer) require_equal(VK_PIPELINE_BIND_POINT_GRAPHICS, bind_pipeline.int_pipelineBindPoint) require_not_equal(0, bind_pipeline.int_pipeline)
def get_descriptor_pool_create_info(create_descriptor_pool, architecture): """Returns a VulkanStruct representing the VkDescriptorPoolCreateInfo struct used in the given create_descriptor_pool command.""" return VulkanStruct( architecture, DESCRIPTOR_POOL_CREATE_INFO_ELEMENTS, lambda offset, size: little_endian_bytes_to_int(require( create_descriptor_pool.get_read_data( create_descriptor_pool.hex_pCreateInfo + offset, size))))
def expect(self): architecture = self.architecture device_properties = require(self.next_call_of( "vkGetPhysicalDeviceProperties")) createSwapchain = require(self.next_call_of("vkCreateSwapchainKHR")) destroySwapchain = require(self.next_call_of("vkDestroySwapchainKHR")) def get_swapchain_create_info_member(offset, size): return little_endian_bytes_to_int(require( createSwapchain.get_read_data(createSwapchain.hex_pCreateInfo + offset, size))) swapchain_create_info = VulkanStruct( architecture, [("sType", UINT32_T), ("pNext", POINTER), ("flags", UINT32_T), ("surface", HANDLE), ("minImageCount", UINT32_T), ("imageFormat", UINT32_T), ("imageColorSpace", UINT32_T), ("extent.width", UINT32_T), ("extent.height", UINT32_T), ("imageArrayLayers", UINT32_T), ("imageUsage", UINT32_T), ("imageSharingMode", UINT32_T), ("queueFamilyIndexCount", UINT32_T), ("queueFamilyIndices", POINTER), ("preTransform", UINT32_T), ("compositeAlpha", UINT32_T), ("presentMode", UINT32_T), ("clipped", UINT32_T), ("oldSwapchain", HANDLE) # oldSwapchain ], get_swapchain_create_info_member) require_equal(swapchain_create_info.sType, VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR) require_equal(swapchain_create_info.oldSwapchain, 0) require_equal(swapchain_create_info.clipped, 0) require_equal(swapchain_create_info.imageArrayLayers, 1) require_not_equal(0, destroySwapchain.int_swapchain) require_equal(True, (swapchain_create_info.queueFamilyIndexCount == 0 or swapchain_create_info.queueFamilyIndexCount == 2))
def expect(self): draw = require(self.next_call_of("vkCmdDraw")) require_not_equal(0, draw.int_commandBuffer) require_equal(3, draw.int_vertexCount) require_equal(1, draw.int_instanceCount) require_equal(0, draw.int_firstVertex) require_equal(0, draw.int_firstInstance)
def expect(self): draw = require(self.next_call_of("vkCmdDrawIndexedIndirect")) require_not_equal(0, draw.int_commandBuffer) require_not_equal(0, draw.int_buffer) require_equal(0, draw.int_offset) require_equal(1, draw.int_drawCount) require_equal(0, draw.int_stride)
def check_destroy_descriptor_pool(test, device, descriptor_pool): """Checks that the next vkDestroyDescriptorPool command call atom has the passed-in |device| and |descriptor_pool| handle value. """ destroy_descriptor_pool = require( test.next_call_of("vkDestroyDescriptorPool")) require_equal(device, destroy_descriptor_pool.int_device) require_equal(descriptor_pool, destroy_descriptor_pool.int_descriptorPool)
def expect(self): """2. Expects vkCmdResetQueryPool() is called with firstQuery: 1, queryCount: 5.""" reset_query_pool = require(self.nth_call_of("vkCmdResetQueryPool", 2)) require_not_equal(0, reset_query_pool.int_commandBuffer) require_not_equal(0, reset_query_pool.int_queryPool) require_equal(1, reset_query_pool.int_firstQuery) require_equal(5, reset_query_pool.int_queryCount)
def GetMappedLocation(test): require(test.nth_call_of("vkDestroyBuffer", 3)) map_coherent_memory = require(test.next_call_of("vkMapMemory")) require_equal(VK_SUCCESS, int(map_coherent_memory.return_val)) require_not_equal(0, map_coherent_memory.int_device) require_not_equal(0, map_coherent_memory.int_memory) # All vkMapMemory called in this test has offset 0. require_equal(0, map_coherent_memory.int_offset) require_true(map_coherent_memory.int_size >= BUFFER_SIZE) require_equal(0, map_coherent_memory.int_flags) require_not_equal(0, map_coherent_memory.hex_ppData) pData = little_endian_bytes_to_int( require( map_coherent_memory.get_write_data( map_coherent_memory.hex_ppData, test.architecture.int_pointerSize))) return pData
def get_image_info(update_atom, architecture, base): """Returns a VulkanStruct representing the VkDescriptorImageInfo struct used in the VkWriteDescriptorSet parameter of the given |update_atom| atom.""" return VulkanStruct( architecture, DESCRIPTOR_IMAGE_INFO_ELEMENTS, lambda offset, size: little_endian_bytes_to_int( require(update_atom.get_read_data(base + offset, size))))
def expect(self): architecture = self.architecture create_pipeline = require(self.nth_call_of("vkCreatePipelineLayout", 3)) require_not_equal(0, create_pipeline.int_device) require_not_equal(0, create_pipeline.hex_pCreateInfo) require_equal(0, create_pipeline.hex_pAllocator) require_not_equal(0, create_pipeline.hex_pPipelineLayout) created_pipeline = little_endian_bytes_to_int( require( create_pipeline.get_write_data( create_pipeline.hex_pPipelineLayout, NON_DISPATCHABLE_HANDLE_SIZE))) pipeline_layout_create_info = VulkanStruct( architecture, PIPELINE_LAYOUT_CREATE_INFO, get_read_offset_function(create_pipeline, create_pipeline.hex_pCreateInfo)) require_equal(VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, pipeline_layout_create_info.sType) require_equal(0, pipeline_layout_create_info.pNext) require_equal(0, pipeline_layout_create_info.flags) require_equal(2, pipeline_layout_create_info.setLayoutCount) require_not_equal(0, pipeline_layout_create_info.pSetLayouts) require_equal(0, pipeline_layout_create_info.pushConstantRangeCount) require_equal(0, pipeline_layout_create_info.pPushConstantRanges) _ = require( create_pipeline.get_read_data( pipeline_layout_create_info.pSetLayouts, NON_DISPATCHABLE_HANDLE_SIZE)) _ = require( create_pipeline.get_read_data( pipeline_layout_create_info.pSetLayouts + NON_DISPATCHABLE_HANDLE_SIZE, NON_DISPATCHABLE_HANDLE_SIZE)) set_layout = little_endian_bytes_to_int( require( create_pipeline.get_read_data( pipeline_layout_create_info.pSetLayouts, NON_DISPATCHABLE_HANDLE_SIZE))) require_not_equal(VK_NULL_HANDLE, set_layout) set_layout2 = little_endian_bytes_to_int( require( create_pipeline.get_read_data( pipeline_layout_create_info.pSetLayouts + NON_DISPATCHABLE_HANDLE_SIZE, NON_DISPATCHABLE_HANDLE_SIZE))) require_not_equal(VK_NULL_HANDLE, set_layout2) destroy_pipeline = require( self.next_call_of("vkDestroyPipelineLayout")) require_equal(created_pipeline, destroy_pipeline.int_pipelineLayout) require_equal(create_pipeline.int_device, destroy_pipeline.int_device) require_equal(0, destroy_pipeline.hex_pAllocator)
def expect(self): """2. Expects a buffer view created with non-zero offset and non-VK_WHOLE_SIZE range for a storage texel buffer.""" architecture = self.architecture device_properties = require( self.next_call_of("vkGetPhysicalDeviceProperties")) create_buffer_view = require(self.nth_call_of("vkCreateBufferView", 2)) device = create_buffer_view.int_device require_not_equal(0, device) require_not_equal(0, create_buffer_view.hex_pCreateInfo) require_equal(0, create_buffer_view.hex_pAllocator) require_not_equal(0, create_buffer_view.hex_pView) require_equal(VK_SUCCESS, int(create_buffer_view.return_val)) create_info = VulkanStruct( architecture, BUFFER_VIEW_CREATE_INFO, get_read_offset_function(create_buffer_view, create_buffer_view.hex_pCreateInfo)) require_equal(VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO, create_info.sType) require_equal(0, create_info.pNext) require_equal(0, create_info.flags) require_not_equal(0, create_info.buffer) require_equal(VK_FORMAT_R8G8B8A8_UNORM, create_info.format) require_equal(MIN_TEXEL_BUFFER_OFFSET_ALIGNMENT * 1, create_info.offset) require_equal(MIN_TEXEL_BUFFER_OFFSET_ALIGNMENT * 3, create_info.range) view = VulkanStruct( architecture, BUFFER_VIEW, get_write_offset_function(create_buffer_view, create_buffer_view.hex_pView)) require_not_equal(0, view.handle) destroy_buffer_view = require(self.next_call_of("vkDestroyBufferView")) require_equal(device, destroy_buffer_view.int_device) require_equal(view.handle, destroy_buffer_view.int_bufferView) if self.not_device(device_properties, 0x5BCE4000, NVIDIA_K2200): destroy_null_buffer_view = require( self.next_call_of("vkDestroyBufferView")) require_equal(device, destroy_buffer_view.int_device) require_equal(0, destroy_null_buffer_view.int_bufferView)
def expect(self): """3. Expects a command pool created with VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT | VK_COMMAND_POOL_CREATE_TRANSIENT_BIT, then reset with flag of value VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT, and finally destroyed""" architecture = self.architecture create_command_pool = require( self.nth_call_of("vkCreateCommandPool", 3)) device = create_command_pool.int_device require_not_equal(0, device) require_not_equal(0, create_command_pool.hex_pCreateInfo) require_equal(0, create_command_pool.hex_pAllocator) require_not_equal(0, create_command_pool.hex_pCommandPool) require_equal(VK_SUCCESS, int(create_command_pool.return_val)) create_info = VulkanStruct( architecture, COMMAND_POOL_CREATE_INFO, get_read_offset_function(create_command_pool, create_command_pool.hex_pCreateInfo)) require_equal(VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO, create_info.sType) require_equal(0, create_info.pNext) require_equal( VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT | VK_COMMAND_POOL_CREATE_TRANSIENT_BIT, create_info.flags) require_equal(0, create_info.queueFamilyIndex) command_pool = VulkanStruct( architecture, COMMAND_POOL, get_write_offset_function(create_command_pool, create_command_pool.hex_pCommandPool)) require_not_equal(0, command_pool.handle) reset_pool = require(self.next_call_of("vkResetCommandPool")) require_equal(device, reset_pool.int_device) require_equal(command_pool.handle, reset_pool.int_commandPool) require_equal(VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT, reset_pool.flags) destroy_command_pool = require( self.next_call_of("vkDestroyCommandPool")) require_equal(device, destroy_command_pool.int_device) require_equal(command_pool.handle, destroy_command_pool.int_commandPool)
def expect(self): """3. Expects a query pool to be created with queryCount: 4 and queryType: VK_QUERY_TYPE_PIPELINE_STATISTICS and pipelineStatistics: VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT.""" architecture = self.architecture device_properties = require( self.next_call_of("vkGetPhysicalDeviceProperties")) create_device = self.nth_call_of("vkCreateDevice", 1) if create_device[0] is None: raise GapidUnsupportedException( "physical device feature: pipelineStatistics not supported") create_query_pool = require(self.next_call_of("vkCreateQueryPool")) device = create_query_pool.int_device require_not_equal(0, device) require_not_equal(0, create_query_pool.hex_pCreateInfo) require_equal(0, create_query_pool.hex_pAllocator) require_not_equal(0, create_query_pool.hex_pQueryPool) require_equal(VK_SUCCESS, int(create_query_pool.return_val)) create_info = VulkanStruct( architecture, QUERY_POOL_CREATE_INFO, get_read_offset_function(create_query_pool, create_query_pool.hex_pCreateInfo)) require_equal(VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO, create_info.sType) require_equal(0, create_info.pNext) require_equal(0, create_info.flags) require_equal(VK_QUERY_TYPE_PIPELINE_STATISTICS, create_info.queryType) require_equal(4, create_info.queryCount) require_equal( VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT, create_info.pipelineStatistics) view = VulkanStruct( architecture, QUERY_POOL, get_write_offset_function(create_query_pool, create_query_pool.hex_pQueryPool)) require_not_equal(0, view.handle) destroy_query_pool = require(self.next_call_of("vkDestroyQueryPool")) require_equal(device, destroy_query_pool.int_device) require_equal(view.handle, destroy_query_pool.int_queryPool)